Pruebas de los cambios

Unos 37 minutos de lectura, con 11 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 decidir si un cambio en la búsqueda debe pasar a producción: comparar los resultados de dos sistemas de ranking consulta por consulta, evitar que tus consultas de prueba favorezcan un cambio, calcular el tamaño de una prueba A/B y comparar dos sistemas de ranking mediante el entrelazado de sus resultados.

La tienda que sigue este libro, una tienda en línea de muebles y artículos para el hogar (capítulo 1), todavía usa BM25 en su buscador como línea base. El trabajo sin conexión (offline) de los capítulos anteriores dio a la recuperación semántica una ventaja establecida sobre BM25 (capítulo 3). Cambiar de sistema es un cambio, y también lo es cada ajuste posterior: un embedding más barato, un peso de combinación o un reranker. Cada cambio plantea las mismas cuatro preguntas. ¿Subió el promedio en más de lo que explicaría el ruido? ¿Qué consultas empeoraron? ¿Pueden los juicios puntuar siquiera los nuevos resultados? ¿Se comportarán los compradores como predicen los juicios? Este capítulo responde a ellas en ese orden. Las 30 consultas de prueba de la tienda se convierten en su conjunto de regresión, las consultas fijas con las que se prueba cada cambio, y cada decisión se toma con sus 50 consultas de entrenamiento. La tienda no tiene registros de clics, así que las secciones en línea simulan a los compradores, y los supuestos de cada simulación se indican junto a ella.

El capítulo plantea una sola comparación sobre las consultas de prueba: la recuperación semántica frente a BM25. Siguiendo el capítulo 3, una comparación planificada conserva el 0.05 completo del libro, así que aquí una diferencia se considera establecida si está por debajo de 0.05. Cualquier otra puntuación sobre las consultas de prueba de este capítulo es exploratoria.

Comparar dos ejecuciones consulta por consulta

Último cambio en la edición 2026.11.10

Las dos primeras preguntas, si el promedio subió y qué consultas empeoraron, se responden sobre un conjunto de regresión: consultas fijas, con juicios de relevancia, contra las que se prueba cada cambio antes de publicarlo. El ranker que la tienda usa hoy es el baseline, y el ranker con el cambio es el ranker candidato. Cada uno produce una ejecución, es decir, sus rankings para cada consulta del conjunto. Comparar solo las medias de las ejecuciones no basta, porque un cambio puede subir el promedio y, aun así, empeorar algunas consultas. TREC, las evaluaciones compartidas de sistemas de búsqueda de la Text REtrieval Conference, construyó una tarea en torno a ese riesgo en su pista Web de 2013, puntuando las victorias y derrotas de cada sistema por consulta frente a un baseline (Collins-Thompson et al., 2014). Así que compara las dos ejecuciones: una fila por consulta, con la puntuación del baseline, la del candidato y el cambio. Luego cuenta las victorias, derrotas y empates, y lee las derrotas.

El baseline es BM25 y el candidato es la recuperación semántica, ambos puntuados con nDCG@10 en las consultas de prueba. El ejemplo construye la comparación con pandas, y sus pruebas provienen de lib.significance, que el capítulo 3 construye a mano. Esas pruebas son una prueba de permutación y una prueba t pareada. Junto a ellas aparece un intervalo bootstrap, con el nivel de confianza que coincide con el umbral. El bootstrap y la prueba de permutación remuestrean al azar, así que lib.significance fija la semilla de SciPy con rng (capítulo 3).

diff-semantic-against-bm25.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Scores each test query under BM25 and semantic retrieval, then runs the chapter's one planned comparison on the difference. The verdict rests on the 'permutation test p' and 'established' lines, read against 'threshold'."""import pandas as pdfrom lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsPLANNED_COMPARISONS = 1                      # this chapter's tests on the test queriesthreshold = 0.05 / PLANNED_COMPARISONS       # Bonferroni: one comparison keeps 0.05products, queries, judgments = load_products(), load_queries("test"), qrels("test")baseline = evaluate(LexicalSearch(products).run(queries, k=100), judgments)      # what the store runscandidate = evaluate(SemanticSearch().run(queries, k=100), judgments)            # the changediff = pd.DataFrame({"query": queries["query"], "bm25": baseline["ndcg@10"], "semantic": candidate["ndcg@10"]})# rounded to 3 decimals, as lib.significance rounds before it counts wins, losses and tiesdiff["change"] = (diff["semantic"] - diff["bm25"]).round(3)        # one row per test queryprint(f"bm25 ndcg@10: {diff['bm25'].mean():.3f}")print(f"semantic ndcg@10: {diff['semantic'].mean():.3f}")result = compare(candidate["ndcg@10"], baseline["ndcg@10"], confidence=1 - threshold)    # chapter 3's comparisonprint(f"mean change: {result['mean difference']:.3f}")print(f"threshold: {threshold:g}")print(f"permutation test p: {result['permutation p']:.3f}")print(f"paired t-test p: {result['t-test p']:.3f}")print(f"{(1 - threshold) * 100:g}% interval: {result['ci low']:.3f} to {result['ci high']:.3f}")print("established:", "yes" if result["permutation p"] < threshold else "no")print("wins:", (diff["change"] > 0).sum())print("losses:", (diff["change"] < 0).sum())print("ties:", (diff["change"] == 0).sum())print(f"largest loss: {diff['change'].min():.3f}")print()print(diff[diff["change"] < 0].sort_values("change").round(3).to_string())
Salidapython diff-semantic-against-bm25.py
bm25 ndcg@10: 0.725
semantic ndcg@10: 0.830
mean change: 0.105
threshold: 0.05
permutation test p: 0.001
paired t-test p: 0.003
95% interval: 0.055 to 0.185
established: yes
wins: 21
losses: 7
ties: 2
largest loss: -0.092

                                                     query   bm25  semantic  change
query_id
292                                decorative white pillow  0.467     0.375  -0.092
293                               wood floor protector mat  0.653     0.568  -0.084
482                                   48 inch kitchen hood  1.000     0.921  -0.079
63                                        monthly calendar  1.000     0.931  -0.069
285       48" sliding single track , barn door for laundry  0.592     0.555  -0.037
72                                      fold in half table  1.000     0.965  -0.035
94                kohler whitehaven farmhouse kitchen sink  0.694     0.690  -0.004

La recuperación semántica sube la media de nDCG@10 de 0.725 a 0.830, un cambio de 0.105. Frente al umbral de 0.05, la prueba de permutación da 0.001. ¿Está establecido el cambio? yes. Junto a ella, la prueba t pareada da 0.003, y el intervalo del 95% va de 0.055 to 0.185.

Las derrotas son donde se aprende algo. La recuperación semántica gana en 21 consultas, pierde en 7 y empata en 2, y su mayor derrota es -0.092. Dos de las derrotas dan un tamaño en pulgadas, 48 inch kitchen hood y 48" sliding single track , barn door for laundry: dos consultas, no un patrón. El capítulo 6 prueba el patrón en todas las consultas que contienen un dígito.

Regla práctica: Mantén un conjunto de regresión de consultas juzgadas con el que nunca se ajuste nada, y prueba cada candidato contra el baseline en él. Enumera primero las comparaciones que planeas, e informa cada una con su valor p de permutación, su prueba t y su intervalo. Cuenta victorias, derrotas y empates, y lee cada derrota antes de publicar. Cuando las derrotas parezcan compartir un patrón, compruébalo en las consultas de entrenamiento antes de actuar, y luego corrige ese tipo de consulta o envíalo al baseline.

Pondera las pérdidas más que las ganancias con URisk

Último cambio en la edición 2026.11.8

La diferencia por consulta cuenta las pérdidas, pero el cambio medio sigue tratando una consulta que empeoró en 0.1 y otra que mejoró en 0.1 como si se anularan. Una tienda puede no verlo así: una persona que ayer encontró un producto y hoy no lo encuentra ha sufrido una regresión, y una clasificación algo mejor en otro lugar no la compensa. La evaluación sensible al riesgo cuenta las pérdidas con más peso que las ganancias.

La medida sensible al riesgo de la pista Web de TREC 2013 es URisk. Para cada consulta q, sea Δ(q) la puntuación del candidato menos la de la línea base. Suma las ganancias en las consultas que mejoraron, resta las pérdidas en las consultas que empeoraron, contadas α + 1 veces, y divide entre el número de consultas N:

URisk = (1 / N) × [ sum of Δ(q) over improved queries  −  (α + 1) × sum of |Δ(q)| over hurt queries ]

La pista describe esto como «ponderar las pérdidas α + 1 veces tanto como los éxitos», y α = 0 da el cambio medio simple (Collins-Thompson et al., sección 4.3). El resumen de la pista imprime el término de pérdida con el propio Δ(q), que es negativo en una consulta perjudicada. Nosotros usamos su tamaño, |Δ(q)|, que es la única lectura con la que α = 0 da la media, como dice el resumen. α es una elección, no un hecho. Usamos α = 1, de modo que cada pérdida cuenta el doble.

Comparemos dos candidatos frente a BM25. El primero es la recuperación semántica completa, con los 768 números de cada embedding de Snowflake/snowflake-arctic-embed-m-v1.5. El segundo conserva solo los primeros 128 números, una sexta parte de la memoria. Eso está por debajo de las 256 dimensiones que documenta la ficha del modelo, y el capítulo 6 descartó 128 con las consultas de entrenamiento. Lo usamos porque, con las consultas de prueba, intercambia ganancias en unas consultas por pérdidas en otras, que es para lo que sirve URisk. Elegido por cómo se comporta en la prueba, es exploratorio, no una comparación planificada. URisk ocupa unas pocas líneas; ejecútalo para ambos candidatos:

urisk-of-two-candidates.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""URisk for full semantic retrieval and for the 128-number version, each against BM25, with every loss counted alpha + 1 times. The prose's point rests on the 'semantic 128 urisk with alpha 1' line, read against its mean change."""from lib.lexical import LexicalSearchfrom lib.metrics import evaluatefrom lib.semantic import SemanticSearchfrom lib.significance import comparefrom lib.store import load_products, load_queries, qrelsALPHA = 1                                   # each loss counts alpha + 1 times: here, doubledef urisk(change, alpha):    """Mean change per query, with every loss counted alpha + 1 times (TREC 2013 Web track)."""    # gains are the positive changes; losses are the negative ones, made positive    wins, losses = change.clip(lower=0).sum(), -change.clip(upper=0).sum()    return (wins - (alpha + 1) * losses) / len(change)products, queries, judgments = load_products(), load_queries("test"), qrels("test")baseline = evaluate(LexicalSearch(products).run(queries, k=100), judgments)candidates = {"semantic": SemanticSearch(), "semantic 128": SemanticSearch(dims=128)}   # all 768 numbers, or the first 128print(f"bm25 judged@10: {baseline['judged@10'].mean():.3f}")evaluated = {name: evaluate(search.run(queries, k=100), judgments) for name, search in candidates.items()}for name, scores in evaluated.items():    # rounded to 3 decimals, so the wins and losses count the printed changes    change = (scores["ndcg@10"] - baseline["ndcg@10"]).round(3)    print(f"{name} judged@10: {scores['judged@10'].mean():.3f}")    print(f"{name} mean change: {change.mean():.3f}")    print(f"{name} wins: {(change > 0).sum()}")    print(f"{name} losses: {(change < 0).sum()}")    print(f"{name} largest loss: {change.min():.3f}")    print(f"{name} urisk with alpha {ALPHA}: {urisk(change, ALPHA):.3f}")# a demonstration, chosen for how it behaves on test: its tests describe it, and it is never establishedresult = compare(evaluated["semantic 128"]["ndcg@10"], baseline["ndcg@10"], confidence=0.95)print(f"semantic 128 permutation test p: {result['permutation p']:.3f}")print(f"semantic 128 paired t-test p: {result['t-test p']:.3f}")print(f"semantic 128 interval: {result['ci low']:.3f} to {result['ci high']:.3f}")
Salidapython urisk-of-two-candidates.py
bm25 judged@10: 0.927
semantic judged@10: 0.990
semantic mean change: 0.105
semantic wins: 21
semantic losses: 7
semantic largest loss: -0.092
semantic urisk with alpha 1: 0.092
semantic 128 judged@10: 0.920
semantic 128 mean change: 0.017
semantic 128 wins: 15
semantic 128 losses: 13
semantic 128 largest loss: -0.253
semantic 128 urisk with alpha 1: -0.033
semantic 128 permutation test p: 0.592
semantic 128 paired t-test p: 0.597
semantic 128 interval: -0.036 to 0.088

El cambio medio de la recuperación semántica completa es 0.105, y su URisk es 0.092. Sus 7 pérdidas son pequeñas, la mayor de -0.092, así que duplicarlas cuesta poco.

El cambio medio del ranker más barato es 0.017, pero con las pérdidas contadas el doble su URisk es -0.033. Gana en 15 consultas y pierde en 13, y su mayor pérdida es -0.253. Su media oculta ese intercambio: mejores resultados en unas consultas, pagados con peores resultados en otras.

Su prueba de permutación da 0.592, la prueba t pareada 0.597, y el intervalo del 95 % va de -0.036 to 0.088.

Algunas de sus pérdidas pueden ser productos que nadie juzgó, ya que su judged@10 es 0.920, frente a 0.927 de BM25 y 0.990 de la recuperación semántica completa. La siguiente sección lo comprueba.

URisk describe el riesgo sin ponerlo a prueba. Dinçer et al. definen una medida relacionada, TRisk, que «es una transformación lineal del estadístico t», por lo que puede someterse a prueba como la prueba t pareada (Dinçer et al., 2014).

Regla práctica: Informa URisk con α = 1 junto al cambio medio para cada candidato. No publiques un candidato cuyo URisk sea negativo, sea cual sea su media, y lee sus pérdidas para averiguar por qué. Sube α cuando los fallos sean caros, e informa URisk por separado sobre las consultas más frecuentes de la tienda. Usa α = 0 solo cuando una pérdida en una consulta no sea peor que una ganancia en otra.

Juzga los productos que un nuevo ranker muestra

Último cambio en la edición 2026.11.10

Las derrotas de un nuevo ranker, como las del ranker más barato en el ejemplo de URisk, pueden deberse a vacíos en los juicios, que solo cubren los productos que hallaron los sistemas anteriores. WANDS, la fuente de los juicios de la tienda, juzgó únicamente lo que encontraron sistemas anteriores (capítulo 2). Un ranker distinto de ellos muestra productos que nadie juzgó, y las métricas asignan a cada uno una calificación de 0, así que su puntuación puede ser demasiado baja o exactamente correcta. No puedes saber cuál hasta que alguien los juzgue. Los autores de WANDS advierten que vacíos como estos debilitan la evaluación: "la incompletitud en el conjunto de datos de Product Search afecta negativamente al poder discriminativo de la evaluación" (Chen et al., 2022).

El capítulo 2 cuenta los productos sin juzgar con judged@10. Para probar un cambio ayuda un paso más: una comprobación de sensibilidad, que recalcula la puntuación de ambas ejecuciones bajo dos escenarios, cada uno favorable a un bando. En uno, todos los productos sin juzgar de los top 10 de la línea base se consideran exactos; en el otro, todos los de la candidata. Ambas ejecuciones se puntúan con los mismos juicios en cada escenario, porque el ranking ideal de nDCG se construye con todos los juicios de la consulta: un producto juzgado como exacto eleva el ideal y, con ello, baja la puntuación de cada ejecución que no lo muestra. Los escenarios no son cotas, ya que los juicios reales podrían mezclar ambos casos. Si el líder cambia entre ellos, los juicios todavía no pueden decidir.

La recuperación semántica más barata de el ejemplo de URisk, que conserva 128 de los 768 números de cada embedding, perdió 13 de las consultas de prueba de la tienda frente a BM25. Antes de sacar conclusiones de esas derrotas, ejecuta la comprobación:

unjudged-score-range.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Mean nDCG@10 for BM25, the cheaper ranker and full semantic retrieval, when each run's unjudged top-10 products are judged exact in turn. The prose's point rests on the 'leader changes' line for semantic 128 against BM25, read against the scores printed before it."""import numpy as npfrom lib.lexical import LexicalSearchfrom lib.metrics import ndcg_at_kfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsproducts, queries, judgments = load_products(), load_queries("test"), qrels("test")runs = {"bm25": LexicalSearch(products).run(queries, k=100),        "semantic 128": SemanticSearch(dims=128).run(queries, k=100),        "semantic": SemanticSearch().run(queries, k=100)}def unjudged(run):    """(query_id, product_id) pairs in a run's top 10 that nobody judged."""    return {(query_id, product_id) for query_id in judgments for product_id in run[query_id][:10]            if product_id not in judgments[query_id]}def score(run, exact=()):    """Mean nDCG@10 with the given unjudged pairs judged exact, for every run alike: the ideal moves too."""    # a copy of the judgments, so each scenario changes only its own exact pairs    scenario = {query_id: dict(grades) for query_id, grades in judgments.items()}    # grade 2 is exact, the top grade    for query_id, product_id in exact:        scenario[query_id][product_id] = 2    return np.mean([ndcg_at_k(run[query_id], scenario[query_id], 10) for query_id in scenario])for name in ["bm25", "semantic 128"]:    print(f"unjudged pairs in the top 10, {name}: {len(unjudged(runs[name]))}")# the empty set is the judgments as they arescenarios = {"as judged": set(), **{f"{name}'s unjudged exact": unjudged(runs[name]) for name in runs}}scores = {(scenario, name): score(run, exact) for scenario, exact in scenarios.items() for name, run in runs.items()}for scenario, name in [("as judged", "bm25"), ("as judged", "semantic 128"), ("bm25's unjudged exact", "bm25"),                       ("bm25's unjudged exact", "semantic 128"), ("bm25's unjudged exact", "semantic"),                       ("semantic 128's unjudged exact", "bm25"), ("semantic 128's unjudged exact", "semantic 128")]:    print(f"{scenario}, {name}: {scores[scenario, name]:.3f}")for candidate in ["semantic 128", "semantic"]:    # a set holding both True and False means the leader changes between scenarios    leaders = {scores[s, candidate] > scores[s, "bm25"] for s in scenarios}    print(f"leader changes, {candidate} against bm25:", "yes" if len(leaders) > 1 else "no")# | is the union: pairs either run shows, each counted onceprint("pairs to judge, semantic 128 against bm25:", len(unjudged(runs["bm25"]) | unjudged(runs["semantic 128"])))
Salidapython unjudged-score-range.py
unjudged pairs in the top 10, bm25: 22
unjudged pairs in the top 10, semantic 128: 24
as judged, bm25: 0.725
as judged, semantic 128: 0.742
bm25's unjudged exact, bm25: 0.788
bm25's unjudged exact, semantic 128: 0.738
bm25's unjudged exact, semantic: 0.829
semantic 128's unjudged exact, bm25: 0.718
semantic 128's unjudged exact, semantic 128: 0.807
leader changes, semantic 128 against bm25: yes
leader changes, semantic against bm25: no
pairs to judge, semantic 128 against bm25: 46

¿Cambia el líder? yes. Así que los juicios todavía no pueden resolver la comparación. Según los juicios, el ranker más barato lidera, 0.742 a 0.725.

Si los productos sin juzgar de BM25 fueran exactos, BM25 lideraría, 0.788 a 0.738. Si lo fueran los del ranker más barato, lideraría este, 0.807 a 0.718.

Los top 10 de BM25 contienen 22 pares sin juzgar, y los del ranker más barato contienen 24. La comparación depende de 46 juicios, un coste pequeño frente al de desplegar el ranker equivocado.

No adivines lo que dirán los jueces. En una colección antigua de TREC, Voorhees et al. juzgaron nuevos conjuntos de documentos procedentes de ejecuciones neuronales y de BM25, y hallaron que la gran mayoría de los documentos nuevos no eran relevantes (Voorhees et al., 2022). Pero esa colección se reunió en profundidad a partir de muchos sistemas, y WANDS se construyó de otra manera. Los juicios humanos son la referencia. Los juicios de un modelo de lenguaje grande (LLM) son más baratos. El capítulo 4 rellena los pares sin juzgar de la tienda con ellos, como diagnóstico, y pide a personas que juzguen los pares siempre que las calificaciones rellenadas cambien un veredicto o el orden de dos rankers. Thomas et al. señalan un riesgo que importa al probar cambios: las etiquetas hechas por un LLM pueden favorecer a los rankers que también usan un LLM (Thomas et al., 2024).

Regla práctica: Para cada candidato, calcula judged@10 para ambas ejecuciones y recalcula sus puntuaciones bajo los dos escenarios. Cuando el líder cambie, juzga los pares sin juzgar antes de comparar, y añade los nuevos juicios al conjunto de regresión de forma permanente, para que cubra cada ranker que hayas probado. Cuando el líder se mantenga en ambos escenarios, es poco probable que los productos sin juzgar inviertan la comparación.

Mantén las consultas de prueba fuera de cada elección

Último cambio en la edición 2026.11.8

Las consultas de prueba del conjunto de regresión están reservadas, y las consultas reservadas solo dan una puntuación honesta si ninguna elección se hizo mirándolas. Entrenar con consultas de prueba es el error obvio. Elegir con ellas es el error sutil: prueba varias configuraciones, conserva la que mejor puntúa en ellas e informa esa puntuación. El ganador es en parte la mejor configuración y en parte la más afortunada con esas consultas concretas, así que su puntuación es demasiado alta. Dwork et al. exponen el riesgo: "Reutilizar un conjunto de reserva de forma adaptativa varias veces puede llevar fácilmente a sobreajustar el propio conjunto de reserva" (Dwork et al., 2015). El daño puede ser menor de lo que se teme. Cuando se reconstruyó el conjunto de prueba de ImageNet, los clasificadores perdieron precisión, pero los resultados de Recht et al. sugieren que la adaptividad no causa esas caídas: las nuevas imágenes eran más difíciles (Recht et al., 2019). En nuestra opinión, un conjunto de 30 consultas deja poco margen, y cada vistazo cuenta.

El cambio es una mezcla de recuperación con BM25 y recuperación semántica con un solo peso, la parte que se da a la recuperación semántica. El capítulo 7 llama a este peso α, una α distinta de la de URisk, y lo ajusta con las consultas de entrenamiento usando fusión ponderada por rango recíproco, sobre 0, 0.1, … 1. Elige el peso semántico de las dos maneras, la correcta con las consultas de entrenamiento y la incorrecta con las consultas de prueba, e informa cada elección sobre las consultas de prueba. Estas puntuaciones de prueba muestran el sesgo; son exploratorias, no una comparación planificada. Después mide cuánto infla su puntuación elegir con las consultas sobre las que se informa, sin volver a tocar las consultas de prueba: divide al azar, 1,000 veces, las consultas de entrenamiento en 30 para elegir y 20 para informar, y compara la puntuación de las 20 consultas informadas cuando el peso se elige con las 30 con su puntuación cuando se elige con esas mismas 20.

tuning-on-test-inflates.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Chooses the blend's semantic weight on train queries and on test queries, then measures how much choosing on the queries you report inflates their score. The prose's point rests on the 'average inflation' line, read against the two 'test ndcg@10' lines."""import numpy as npfrom lib.blend import best_alpha, scores_by_alpha, weighted_rrffrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsqueries, judgments = load_queries(), qrels()                  # all 80 queries, train and testbm25 = LexicalSearch(load_products()).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)per_query = scores_by_alpha(lambda weight: weighted_rrf(bm25, semantic, weight), judgments)   # nDCG@10, a column per weighttrain = per_query.loc[load_queries("train").index]test = per_query.loc[load_queries("test").index]# best_alpha breaks ties toward the smaller weightchosen_on_train, chosen_on_test = best_alpha(train), best_alpha(test)print("settings tried:", per_query.shape[1])print(f"semantic alone, test ndcg@10: {test[1.0].mean():.3f}")print("semantic weight chosen on train:", chosen_on_train)print(f"test ndcg@10, weight chosen on train: {test[chosen_on_train].mean():.3f}")print("semantic weight chosen on test:", chosen_on_test)print(f"test ndcg@10, weight chosen on test: {test[chosen_on_test].mean():.3f}")# How much does choosing on the queries you report inflate the score? Split the train queries# at random, 30 to choose on and 20 to report on, and compare the two ways of choosing.# a fixed seed, so the random splits are the same on every runrng = np.random.default_rng(2026)scores = train.to_numpy()inflation = []for _ in range(1000):    order = rng.permutation(len(scores))    # the first 30 of the shuffled queries choose the weight; the other 20 report it    choose, report = scores[order[:30]].mean(axis=0), scores[order[30:]].mean(axis=0)    # argmax takes the first of equal means, the smaller weight, as best_alpha does    inflation.append(report.max() - report[choose.argmax()])print(f"average inflation, 20 reported queries: {np.mean(inflation):.3f}")
Salidapython tuning-on-test-inflates.py
settings tried: 11
semantic alone, test ndcg@10: 0.830
semantic weight chosen on train: 0.6
test ndcg@10, weight chosen on train: 0.825
semantic weight chosen on test: 0.8
test ndcg@10, weight chosen on test: 0.835
average inflation, 20 reported queries: 0.007

Elegir el peso con las consultas de prueba favorece a la mezcla. Elegido allí, el peso semántico es 0.8, y la mezcla obtiene 0.835.

Elegido con las de entrenamiento, es 0.6, y la mezcla obtiene 0.825 en las consultas de prueba, frente a 0.830 para la recuperación semántica sola. Solo esa puntuación elegida con entrenamiento estima de forma justa cómo se comporta la mezcla en consultas que no se usaron para elegirla. El capítulo 7 contrasta la mezcla elegida con entrenamiento frente a la recuperación semántica y no encuentra mejora.

Las divisiones aleatorias cuantifican el sesgo. En conjuntos informados de 20 consultas, elegir con las consultas que informas añade 0.007 a nDCG@10 de media, con 11 configuraciones entre las que elegir. Esa ganancia aparece en el informe y en ningún otro lugar. Cada configuración adicional que pruebas es otra oportunidad para un ganador afortunado.

Regla práctica: Elige cada configuración con consultas de entrenamiento, incluido qué candidato llevar adelante. Mira las consultas de prueba una vez por decisión, y registra cada vistazo: qué comparaste y qué elegiste. Cuando un conjunto de prueba haya guiado muchas decisiones, pásalo al lado de entrenamiento y evalúa un conjunto nuevo de consultas de prueba.

Ejecutar una prueba A/B

Último cambio en la edición 2026.11.10

Las pruebas sin conexión miden las clasificaciones frente a juicios, pero la tienda gana dinero con sus compradores. Una prueba A/B, o experimento controlado, asigna a los usuarios al azar al sistema actual o al cambio, y compara una métrica elegida antes de que empiece la prueba (Kohavi et al., 2009). El sistema actual es el control, y el sistema modificado es el tratamiento.

Tres comprobaciones hacen fiable el resultado. Primero, una prueba A/A, en la que ambos grupos reciben el mismo sistema, debería rechazar la hipótesis nula alrededor del 5 % de las veces con un nivel de confianza del 95 % (Kohavi et al., 2009). Un porcentaje muy superior al 5 % indica una configuración defectuosa. Segundo, lee el resultado una sola vez, al tamaño que planificaste. Detener una prueba en cuanto parece significativa, lo que se llama mirar antes de tiempo (peeking), aumenta considerablemente la tasa de error de tipo I (Kohavi et al., 2022). Tercero, comprueba que los grupos tengan el tamaño que planificaste. Un desajuste en la proporción de muestra (SRM, por sus siglas en inglés) significa que usuarios desaparecieron de un grupo o se añadieron a él de forma desigual, y «ignorar el SRM sin conocer la causa raíz puede hacer que una modificación del producto mala parezca buena» (Fabijan et al., 2019).

Para una métrica de conversión, la proporción de compradores que compran, la prueba compara dos proporciones. Con tasas p_A y p_B sobre n compradores en cada grupo, y p̄ su promedio:

z = (p_B − p_A) / sqrt( p̄ × (1 − p̄) × 2 / n ),   p-value = 2 × P(Z > |z|)

Simula 2,000 pruebas A/A bajo supuestos declarados, para ver qué hace mirar antes de tiempo: 2,000 compradores al día en cada grupo, 5 % compran, y cada prueba planificada para 14 días. Lee cada una al final planificado, y también cada día, deteniéndote en el primer valor p por debajo de 0.05. Luego comprueba si una división presenta un desajuste.

aa-tests-with-peeking.py Python 3.12.15 · numpy 2.5.5 · scipy 1.18.1 Superado
"""Simulates A/A tests, where both groups get the same search, read at the planned end and every day, and checks one split for a mismatch. The prose's point rests on the 'significant at the planned end' and 'significant on some day' lines, and on the sample ratio mismatch line."""import numpy as npfrom scipy import stats# Assumptions for the simulation, not the store's data: 2,000 shoppers a day in each group,# 5% of them buy, and the test is planned to run 14 days. Both groups get the same search (an A/A test).TESTS, DAYS, SHOPPERS_PER_DAY, CONVERSION = 2000, 14, 2000, 0.05# a fixed seed, so the simulated tests are the same on every runrng = np.random.default_rng(2026)buyers = rng.binomial(SHOPPERS_PER_DAY, CONVERSION, size=(TESTS, DAYS, 2)).cumsum(axis=1)   # running totalsshoppers = SHOPPERS_PER_DAY * np.arange(1, DAYS + 1)[None, :]                               # per group, by dayrate_a, rate_b = buyers[..., 0] / shoppers, buyers[..., 1] / shopperspooled = (rate_a + rate_b) / 2# two-proportion z for each day, using the pooled rate of the two groupsz = (rate_b - rate_a) / np.sqrt(pooled * (1 - pooled) * 2 / shoppers)# two-sided: a gap in either direction countsp_value = 2 * stats.norm.sf(np.abs(z))print(f"simulated A/A tests: {TESTS:,}")# the last day is the planned end, day 14print(f"significant at the planned end: {(p_value[:, -1] < 0.05).mean():.3f}")print(f"significant on some day, checked daily: {(p_value < 0.05).any(axis=1).mean():.3f}")# A sample ratio mismatch: the split was planned 50/50, but the groups came out unequal.control, treatment = 28_000, 27_100# the default expected share is one half, as in a 50/50 splitp = stats.binomtest(treatment, control + treatment).pvalueprint(f"sample ratio mismatch p: {p:.3f}" if p >= 0.001 else "sample ratio mismatch p: below 0.001")
Salidapython aa-tests-with-peeking.py
simulated A/A tests: 2,000
significant at the planned end: 0.053
significant on some day, checked daily: 0.231
sample ratio mismatch p: below 0.001

Revisar cada día hace que muchas más pruebas A/A parezcan significativas. Si se lee al final planificado, la proporción que resulta significativa es 0.053, cercana al 0.05 que promete el umbral. Revisado diariamente, la proporción que parece significativa en algún día sube a 0.231, aunque la búsqueda de ninguno de los dos grupos cambió. Para una división planificada 50/50 que resulta en 28,000 frente a 27,100, una prueba binomial de 27,100 de 55,100 compradores contra la mitad da un valor p below 0.001: el azar casi nunca produce una diferencia de ese tamaño.

El valor p se interpreta a menudo mal: 0.05 no significa un 5 % de probabilidad de que el resultado sea un falso positivo; Kohavi et al. (2022) lo llaman «un malentendido muy común». Es la probabilidad de datos al menos tan extremos si el cambio no hizo nada.

Regla práctica: Antes de la prueba, elige la métrica principal y las barreras de protección que no deben empeorar, y calcula el tamaño de la prueba (con potencia). Ejecuta primero una prueba A/A con la misma configuración. Comprueba la proporción de muestra antes de leer cualquier resultado, y lee el resultado una sola vez, al tamaño planificado. Si debes vigilar una prueba mientras se ejecuta, usa un método secuencial diseñado para el monitoreo continuo, como los valores p siempre válidos (Johari et al., 2015).

Dimensionar la prueba con potencia

Último cambio en la edición 2026.11.8

Leer una prueba A/B una sola vez, con su tamaño planificado, exige planificar ese tamaño primero, a partir de la potencia de la prueba: la probabilidad de que detecte un cambio real de un tamaño dado. Una prueba con muy poca potencia pasa por alto cambios reales, y cuando sale significativa tiende a exagerar: «un hallazgo estadísticamente significativo con baja potencia probablemente exagerará en gran medida el tamaño del efecto» (Kohavi et al., 2022). Por eso conviene decidir el tamaño antes de que empiece la prueba, a partir de dos números: cuánto varía la métrica entre usuarios y el cambio más pequeño que vale la pena detectar. Más varianza exige más usuarios. Un cambio más pequeño exige muchos más, porque el cambio entra elevado al cuadrado.

Para dos grupos, con 95% de confianza y 80% de potencia, Kohavi et al. dan una regla práctica, con σ² la varianza de la métrica y Δ el cambio que se quiere detectar (Kohavi et al., 2009):

users per group ≈ 16 × σ² / Δ²

El 16 proviene de la distribución normal: 2 × (z para 97.5% + z para 80%)², es decir, aproximadamente 2 × (1.96 + 0.84)². Para una potencia de 90%, reemplazan el 16 por 21. SciPy calcula el coeficiente, y el código comprueba la regla con sus dos ejemplos trabajados: el ingreso por usuario, con una media de 3.75 dólares y una desviación estándar de 30 dólares, y una tasa de conversión de 5%, en ambos casos con un cambio relativo de 5% por detectar. Los datos de la tienda, procedentes de WANDS, no incluyen cifras de ventas, así que el código supone que la tienda también convierte al 5%.

sample-size-from-power.py Python 3.12.15 · scipy 1.18.1 Superado
"""Kohavi et al.'s rule of thumb for users per group, its coefficient, and the users the store would need for smaller changes, assuming its 5% conversion rate. The prose's point rests on the two 'users per group for a change' lines, read against the coefficient line."""from scipy import statsSIGNIFICANCE, POWER = 0.05, 0.80z = stats.norm.ppf(1 - SIGNIFICANCE / 2) + stats.norm.ppf(POWER)    # 1.96 + 0.84print(f"coefficient for two groups: {2 * z ** 2:.1f}")                # rounds to the 16 of the rule of thumbdef users_per_group(variance, change):    """Kohavi et al.'s rule of thumb: about 16 * variance / change**2 users in each group."""    return 16 * variance / change ** 2# Their worked examples: revenue per user (mean $3.75, standard deviation $30), and a 5% conversion rate,# each with a 5% relative change to detect.print(f"users per group, revenue: {users_per_group(30 ** 2, 0.05 * 3.75):,.0f}")# a conversion rate's variance is p times (1 - p), here with p = 5%; the change is 5% of that rateprint(f"users per group, conversion: {users_per_group(0.05 * 0.95, 0.05 * 0.05):,.0f}")# The store, assuming a 5% conversion rate like theirs: smaller changes need far more users.for relative in [0.02, 0.01]:    # the change in conversion, as an absolute rate: a relative change of this size in the 5% rate    print(f"users per group for a {relative:.0%} change: {users_per_group(0.05 * 0.95, 0.05 * relative):,.0f}")
Salidapython sample-size-from-power.py
coefficient for two groups: 15.7
users per group, revenue: 409,600
users per group, conversion: 121,600
users per group for a 2% change: 760,000
users per group for a 1% change: 3,040,000

Si se reduce a la mitad el cambio, se necesitan cuatro veces más usuarios: con la conversión supuesta de 5% para la tienda, un cambio de 2% requiere 760,000 usuarios por grupo y un cambio de 1% requiere 3,040,000.

El coeficiente es 15.7, y los ejemplos de ingreso y de conversión necesitan 409,600 y 121,600 usuarios por grupo, lo que coincide con las cifras del artículo, de más de 409,000 y menos de 122,000.

La misma aritmética indica qué puede detectar el conjunto de regresión. Ambos rankers puntúan las mismas consultas, así que la prueba trabaja con una sola muestra de diferencias por consulta en lugar de con dos grupos, y el coeficiente se reduce a la mitad, hasta 7.8. Toma σ como la dispersión de esas diferencias entre dos rankers parecidos: la recuperación semántica y la ejecución híbrida que la fusiona con BM25.

queries-needed-for-power.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""The smallest change the regression set detects with 80% power, from the spread of per-query changes, and a simulation that checks the power formula. The prose's point rests on the 'smallest change 30 queries detect' line and the simulated power lines."""import numpy as npfrom scipy import statsfrom 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, qrelsSIGNIFICANCE, POWER = 0.05, 0.80queries, judgments = load_queries("test"), qrels("test")bm25 = LexicalSearch(load_products()).run(queries, k=100)semantic = SemanticSearch().run(queries, k=100)hybrid = reciprocal_rank_fusion([bm25, semantic])change = evaluate(hybrid, judgments)["ndcg@10"] - evaluate(semantic, judgments)["ndcg@10"]spread = change.std()                                     # of the per-query differencesz = stats.norm.ppf(1 - SIGNIFICANCE / 2) + stats.norm.ppf(POWER)print(f"spread of per-query changes: {spread:.3f}")print(f"coefficient for paired queries: {z ** 2:.1f}")     # one sample of differences, so half of 16# z standard errors of the mean change: the smallest change the test can detectdetectable = z * spread / np.sqrt(len(change))print(f"smallest change 30 queries detect: {detectable:.3f}")# n = z squared times spread squared, over the change squared, solved for nprint(f"queries needed for a change of 0.01: {z ** 2 * spread ** 2 / 0.01 ** 2:.0f}")# Check the arithmetic by simulation: draw 30 normally distributed changes with that mean and spread,# 10,000 times, and test each. The real differences aren't normal, so this checks the formula, not the data.rng = np.random.default_rng(2026)# ttest_1samp tests each draw against popmean 0, the no-change nullpower = stats.power(stats.ttest_1samp, lambda size: rng.normal(detectable, spread, size=size), (len(change),),                    significance=SIGNIFICANCE, kwargs={"popmean": 0})# .item() takes the single value out of the result, which holds one simulated powerprint(f"simulated power at that change: {power.power.item():.3f}")print("simulated power below the planned 0.8:", "yes" if power.power.item() < POWER else "no")
Salidapython queries-needed-for-power.py
spread of per-query changes: 0.062
coefficient for paired queries: 7.8
smallest change 30 queries detect: 0.032
queries needed for a change of 0.01: 300
simulated power at that change: 0.779
simulated power below the planned 0.8: yes

Los cambios por consulta tienen una dispersión de 0.062, así que con 30 consultas de prueba el conjunto de regresión detecta un cambio de 0.032 en nDCG@10 con 80% de potencia. Un cambio de 0.01 necesitaría 300 consultas.

scipy.stats.power comprueba la aritmética mediante simulación, extrayendo diferencias con distribución normal: para ese cambio, la prueba t pareada tiene una potencia simulada de 0.779. ¿Está por debajo del 0.8 planificado? yes, porque la fórmula usa la distribución normal, mientras que la prueba t, sobre las consultas de prueba, usa la distribución t, más ancha. Las diferencias reales no son normales, así que la simulación comprueba la fórmula, no los datos. Cuando añadas consultas, añade muchas y júzgalas de forma superficial: Webber et al. comprobaron que, con el mismo esfuerzo de juicio, muchas consultas juzgadas superficialmente dan más potencia estadística que pocas juzgadas a fondo (Webber et al., 2008).

Regla práctica: Dimensiona cada prueba A/B antes de que empiece. Si necesita más usuarios de los que la tienda ve en unas pocas semanas, prueba un cambio mayor, usa una métrica que varíe menos o ajusta la métrica con los datos previos de cada usuario. En los experimentos de Bing, Deng et al. informan de que esto «puede reducir la varianza en alrededor de un 50%» (Deng et al., 2013); cuánto se ahorra depende de lo bien que el comportamiento pasado de un usuario prediga la métrica. Sin conexión, calcula el cambio más pequeño que tu conjunto de regresión puede detectar, y añade consultas cuando tus cambios sean más pequeños. Fija el número de antemano: añadir consultas hasta que una estimación de potencia diga que hay suficientes introduce un sesgo hacia encontrar significancia (Webber et al.).

Interleaving de dos rankings con team draft

Último cambio en la edición 2026.11.10

Una prueba A/B muestra a cada grupo un ranking distinto, así que las diferencias entre compradores añaden ruido. Interleaving muestra a cada comprador una sola lista que mezcla los resultados de dos rankers. Joachims lo diseñó para que "el ranking combinado dé (casi) el mismo sesgo de presentación a ambos motores de búsqueda" (Joachims, 2003): ninguno de los dos rankers tiene sistemáticamente sus productos más arriba. El ranker cuyos productos reciben más clics gana esa búsqueda. El interleaving responde a una pregunta más acotada que una prueba A/B: qué ranking prefieren los usuarios de dos posibles, no un número absoluto para cada uno (Hofmann et al., 2016).

Team draft intercala las listas de dos rankers como si se eligieran equipos para un partido (Radlinski et al., 2008, Algoritmo 2). Juega primero el equipo con menos elecciones, y una moneda decide cuando ambos tienen el mismo número. Cada elección es el producto mejor posicionado en la lista del equipo que todavía no se ha mostrado. Un clic cuenta para el equipo que eligió el producto. Radlinski et al. muestran que con team draft, "un usuario que hace clic al azar siempre producirá, en expectativa, igual número de preferencias por A que por B", algo que un método anterior no garantizaba.

Intercala la recuperación semántica de la tienda y BM25 para la consulta de prueba clear shower curtain. Team draft cabe en unas pocas líneas, con un generador con semilla para sus tiradas de moneda, y el código comprueba que lib.experiments devuelve la misma lista:

team-draft-one-query.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Team draft over one query's semantic and BM25 rankings: the interleaved list, and the team that picked each place. The prose's point rests on the BM25 pick at the bottom of the list, and on the 'same list' line that checks lib.experiments."""import numpy as npfrom lib import experimentsfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsLABELS = {2: "exact", 1: "partial", 0: "irrelevant"}def team_draft(ranking_a, ranking_b, rng, length=10):    """Like picking teams: the team with fewer picks goes next, a coin flip decides when they're level,    and each team adds its best product that isn't shown yet."""    shown, teams = [], []    while len(shown) < length:        picks_a, picks_b = teams.count("a"), teams.count("b")        # the coin is drawn only when the teams are level        a_picks = picks_a < picks_b or (picks_a == picks_b and rng.random() < 0.5)        ranking, team = (ranking_a, "a") if a_picks else (ranking_b, "b")        # the team's best product that isn't shown yet, from its own ranking        shown.append(next(p for p in ranking if p not in shown))        teams.append(team)    return shown, teamsproducts, queries, judgments = load_products(), load_queries("test"), qrels("test")[246]   # clear shower curtainsemantic = list(SemanticSearch().search(246, k=100).index)bm25 = list(LexicalSearch(products).search(queries.at[246, "query"], k=100).index)shown, teams = team_draft(semantic, bm25, np.random.default_rng(7))# judgments.get returns None for a product nobody judged, and LABELS.get then gives 'unjudged'# names are cut at 45 characters to keep the columns alignedfor position, (product_id, team) in enumerate(zip(shown, teams), start=1):    name = {"a": "semantic", "b": "bm25"}[team]    print(f"{position:>2}  {name:<8}  {LABELS.get(judgments.get(product_id), 'unjudged'):<10}  {products.at[product_id, 'name'][:45]}")# lib.experiments holds the same function, which the simulations useprint("same list from lib.experiments:", "yes" if experiments.team_draft(semantic, bm25, np.random.default_rng(7)) == (shown, teams) else "no")
Salidapython team-draft-one-query.py
 1  bm25      partial     rodas vinyl shower curtain
 2  semantic  exact       woolley vinyl solid color single shower curta
 3  bm25      exact       woolley vinyl single shower curtain
 4  semantic  partial     newburg check 3d vinyl single shower curtain
 5  bm25      exact       siniard single shower curtain
 6  semantic  partial     71 '' x71 '' 4pcs shower curtain sets beach t
 7  semantic  exact       almazan lightweight single shower curtain
 8  bm25      exact       simmon vinyl single shower curtain liner
 9  semantic  partial     vinyl striped shower curtain set
10  bm25      irrelevant  gilded pineapple shower curtain hooks
same list from lib.experiments: yes

Team draft siempre asigna a cada ranker 5 puestos de una lista de diez; las tiradas de moneda deciden cuáles. Un producto que ambos rankers colocan alto aparece una sola vez, acreditado al equipo que lo tomó primero, de modo que ningún ranker recibe crédito dos veces por el mismo producto. En esta consulta entra, al final, uno de los ganchos para cortinas de ducha que BM25 ordena (capítulo 1), como última elección de BM25. Los clics de un comprador sobre las elecciones de la recuperación semántica cuentan para la recuperación semántica, los clics sobre las elecciones de BM25 cuentan para BM25, y el equipo con más clics gana la búsqueda.

Regla práctica: Usa el interleaving con team draft para comparar en línea dos rankers cuando necesites saber cuál prefieren los usuarios, con menos búsquedas que una prueba A/B. Usa en cambio una prueba A/B cuando necesites un número absoluto, como los ingresos, o cuando el cambio no esté en el ranking. Según nuestro razonamiento, una lista intercalada no puede mostrar el efecto de la latencia, del diseño de la página o de un número distinto de resultados.

Ensayar el interleaving con compradores simulados

Último cambio en la edición 2026.11.8

WANDS, la fuente de datos de la tienda, no tiene clics, así que la tienda no puede ejecutar team-draft interleaving con compradores reales, pero sí puede ensayarlo con compradores simulados. Un modelo de clics es un modelo probabilístico de cómo los usuarios recorren y hacen clic en una lista de resultados, y se usa tanto para construir métricas como para simular usuarios (Chuklin et al., 2015). El modelo de cascada afirma que los usuarios leen desde arriba y "se van en cuanto ven un documento que vale la pena" (Craswell et al., 2008; véase el capítulo 2). La simulación estándar sigue ese modelo: extrae una consulta al azar con probabilidad uniforme, recorre su lista, hace clic en cada producto con una probabilidad que depende de su calificación y, tras un clic, se marcha con otra probabilidad que también depende de la calificación (Oosterhuis y de Rijke, 2018). La investigación sobre interleaving prueba sus métodos de este modo, con clics simulados a partir de datos etiquetados (Hofmann et al., 2011).

Las probabilidades son supuestos. La Tabla 2 de Oosterhuis y de Rijke presenta un usuario "navegacional" para cinco calificaciones, que busca un único resultado muy relevante, y lo llamamos el comprador navegacional. Asignamos irrelevante, parcial y exacto a las calificaciones más baja, media y más alta de ese usuario, contamos los productos no juzgados como irrelevantes, como hacen las métricas, y extraemos cada consulta con la misma frecuencia. Los valores están en un solo lugar, lib.experiments:

Calificación Clic Abandonar tras el clic
Exacto 0.95 0.9
Parcial 0.5 0.5
Irrelevante 0.05 0.2

Haz que uno de estos compradores recorra a mano la lista de team-draft para clear shower curtain:

one-simulated-shopper.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""One simulated navigational shopper walks the team-draft list for clear shower curtain, clicking and leaving by the cascade model. The prose's point rests on the two 'clicks for' lines and the verdict line, and on the 'same clicks' line that checks lib.experiments."""import numpy as npfrom lib.experiments import NAVIGATIONAL, cascade_clicks, team_draftfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsLABELS = {2: "exact", 1: "partial", 0: "irrelevant"}products, queries, judgments = load_products(), load_queries("test"), qrels("test")[246]   # clear shower curtainsemantic = list(SemanticSearch().search(246, k=100).index)bm25 = list(LexicalSearch(products).search(queries.at[246, "query"], k=100).index)shown, teams = team_draft(semantic, bm25, np.random.default_rng(7))       # the team-draft example's listteam_names = {"a": "semantic", "b": "bm25"}# the same seed as the check at the end, so both draw the same clicksrng = np.random.default_rng(2026)clicks = []for position, product_id in enumerate(shown):    grade = judgments.get(product_id, 0)                                  # unjudged counts as 0    # click and stop probabilities for the grade: 0 irrelevant, 1 partial, 2 exact    clicked = rng.random() < NAVIGATIONAL["click"][grade]    # the second draw happens only after a click, the order cascade_clicks uses    leaves = clicked and rng.random() < NAVIGATIONAL["stop"][grade]        # only a click can end the visit    label = LABELS.get(judgments.get(product_id), "unjudged")    print(f"{position + 1:>2}  {team_names[teams[position]]:<8}  {label:<10}  {'clicks' if clicked else '':<6}  {'leaves' if leaves else ''}")    if clicked:        clicks.append(position)    if leaves:        breakcredited = [team_names[teams[position]] for position in clicks]       # each click counts for the team that picked itfor_semantic, for_bm25 = credited.count("semantic"), credited.count("bm25")print("clicks for semantic:", for_semantic)print("clicks for bm25:", for_bm25)print("this search goes to:", "semantic" if for_semantic > for_bm25 else "bm25" if for_bm25 > for_semantic else "neither, a tie")print("same clicks from lib.experiments:", "yes" if cascade_clicks(shown, judgments, np.random.default_rng(2026)) == clicks else "no")
Salidapython one-simulated-shopper.py
 1  bm25      partial     clicks
 2  semantic  exact       clicks  leaves
clicks for semantic: 1
clicks for bm25: 1
this search goes to: neither, a tie
same clicks from lib.experiments: yes

Los clics del comprador cuentan 1 para la recuperación semántica y 1 para BM25, así que el veredicto para esta búsqueda es neither, a tie. Simula 10,000 búsquedas intercaladas, con una semilla fija, para dos pares: la recuperación semántica frente a BM25, y la ejecución híbrida frente a la recuperación semántica. Una prueba del signo pregunta si las victorias superan a las derrotas más de lo que cabría por azar; Radlinski et al. usan "una prueba binomial del signo", dejando fuera los empates. Lee el veredicto con 100, 1,000 y 10,000 búsquedas:

simulated-interleaving-verdict.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Sign tests on simulated interleaved searches, at 100, 1,000 and 10,000 searches, for two pairs of rankers and a third pair with BM25's ties reversed. The prose's point rests on the 'verdict changes' line and the 100-search lines for the hybrid against semantic retrieval."""import numpy as npfrom scipy import statsfrom lib.experiments import NAVIGATIONAL, simulate_interleavingfrom lib.fusion import reciprocal_rank_fusionfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsfor grade, label in [(2, "exact"), (1, "partial"), (0, "irrelevant")]:      # the assumptions, from lib.experiments    print(f"{label} click probability: {NAVIGATIONAL['click'][grade]}")    print(f"{label} stop probability: {NAVIGATIONAL['stop'][grade]}")# lexsort's last key sorts first: the score, highest first, then the product_id, highest first among tiesdef ties_reversed(scores):              # BM25's ranking, with equal scores in descending product_id order instead    return scores.index[np.lexsort((-scores.index.to_numpy(), -scores.to_numpy()))].tolist()queries, judgments = load_queries("test"), qrels("test")lexical = LexicalSearch(load_products())bm25 = lexical.run(queries, k=100)                                        # equal scores by product_idsemantic = SemanticSearch().run(queries, k=100)hybrid = reciprocal_rank_fusion([bm25, semantic])bm25_reversed = {q: ties_reversed(lexical.search(query, k=100)) for q, query in queries["query"].items()}pairs = {"semantic against bm25": (semantic, bm25), "hybrid against semantic": (hybrid, semantic),         "hybrid with bm25 ties reversed against semantic": (reciprocal_rank_fusion([bm25_reversed, semantic]), semantic)}below = {}for name, (run_a, run_b) in pairs.items():    # a fresh seed for each pair, so every pair sees the same 10,000 queries    outcomes = simulate_interleaving(run_a, run_b, judgments, 10_000, np.random.default_rng(2026))    for searches in [100, 1_000, 10_000]:        # the first 100, 1,000 or 10,000 of the same searches, so the three verdicts share data        wins, losses = (outcomes[:searches] == 1).sum(), (outcomes[:searches] == -1).sum()        p = stats.binomtest(wins, wins + losses).pvalue                  # sign test; ties left out        below[name, searches] = p < 0.05        shown = f"{p:.3f}" if p >= 0.001 else "below 0.001"        print(f"{name}, {searches:,} searches: {wins} wins, {losses} losses, p {shown}")changes = below["hybrid against semantic", 100] != below["hybrid with bm25 ties reversed against semantic", 100]print("hybrid against semantic, verdict at 100 searches changes with bm25 ties reversed:", "yes" if changes else "no")
Salidapython simulated-interleaving-verdict.py
exact click probability: 0.95
exact stop probability: 0.9
partial click probability: 0.5
partial stop probability: 0.5
irrelevant click probability: 0.05
irrelevant stop probability: 0.2
semantic against bm25, 100 searches: 51 wins, 36 losses, p 0.133
semantic against bm25, 1,000 searches: 519 wins, 347 losses, p below 0.001
semantic against bm25, 10,000 searches: 5222 wins, 3552 losses, p below 0.001
hybrid against semantic, 100 searches: 32 wins, 51 losses, p 0.048
hybrid against semantic, 1,000 searches: 413 wins, 447 losses, p 0.260
hybrid against semantic, 10,000 searches: 4180 wins, 4593 losses, p below 0.001
hybrid with bm25 ties reversed against semantic, 100 searches: 35 wins, 48 losses, p 0.187
hybrid with bm25 ties reversed against semantic, 1,000 searches: 410 wins, 463 losses, p 0.078
hybrid with bm25 ties reversed against semantic, 10,000 searches: 4174 wins, 4560 losses, p below 0.001
hybrid against semantic, verdict at 100 searches changes with bm25 ties reversed: yes

Las muestras pequeñas fluctúan mucho. Para la recuperación semántica frente a BM25, con una diferencia grande fuera de línea, el veredicto es 51 wins, 36 losses, p 0.133 con 100 búsquedas y 519 wins, 347 losses, p below 0.001 con 1,000. Para el híbrido frente a la recuperación semántica, es 32 wins, 51 losses, p 0.048 con 100 búsquedas y 413 wins, 447 losses, p 0.260 con 1,000, y por eso conviene fijar el número de búsquedas antes de empezar la prueba.

Con 10,000 búsquedas, el veredicto del híbrido es 4180 wins, 4593 losses, p below 0.001. Eso no anula el hallazgo del capítulo 3 de que no hay una diferencia establecida: con cada vez más clics simulados sobre las mismas 30 consultas, la prueba del signo solo mide ruido de clics, así que cualquier diferencia fija, por pequeña que sea, acaba siendo significativa.

El veredicto del híbrido con 100 búsquedas también depende de un detalle que no aporta información. El híbrido fusiona BM25, y lib.lexical ordena las puntuaciones iguales de BM25 por product_id. Si las ordenas al revés, una regla igual de arbitraria, la misma semilla da 35 wins, 48 losses, p 0.187 con 100 búsquedas. ¿Cambia el veredicto con 0.05? yes. Invertir los empates de BM25 cambia algunas de las listas del híbrido, así que los compradores simulados ven otros productos, y cada sorteo aleatorio posterior a la primera lista modificada puede cambiar. Un veredicto que una regla de empate puede invertir es suerte, no un hallazgo sobre los modelos de ranking.

Tres límites mantienen esto como un ensayo. Los clics provienen de las mismas calificaciones que usa nDCG@10, así que el interleaving tiende a coincidir con nDCG@10; no aporta evidencia adicional sobre los modelos de ranking. Cada búsqueda proviene de las mismas 30 consultas, así que la prueba del signo solo habla de estas consultas. Y los compradores reales no son este modelo. Deffayet et al. estudiaron qué ocurre cuando cambia el modelo de ranking que produjo un registro de clics, y encontraron que los modelos de clics son sensibles a ese cambio (Deffayet et al., 2023). Con tráfico real en tres motores de búsqueda, el interleaving coincidió con los juicios de expertos siempre que ambos fueron significativos, y necesitó "aproximadamente entre 1 y 2 órdenes de magnitud menos datos que las métricas absolutas" (Chapelle et al., 2012). Según nuestro razonamiento, la simulación no puede mostrar esa ventaja, porque todos sus compradores se comportan igual.

Regla práctica: Ensaya una prueba de interleaving en simulación para comprobar tu código y tu prueba del signo. Considera cualquier número de búsquedas que sugiera solo tan fiable como el comprador supuesto, y vuelve a ejecutar un veredicto simulado con los empates resueltos en sentido contrario antes de sacar conclusiones. Nunca presentes un veredicto simulado como evidencia sobre un modelo de ranking. Con tráfico real, fija el número de búsquedas de antemano y decide con una prueba del signo.

Encuentra la causa cuando lo offline y lo online no coinciden

Último cambio en la edición 2026.11.8

Los compradores simulados hacen clic según las mismas calificaciones que usa nDCG@10, así que tienden a coincidir con esta métrica; los compradores reales no tienen por qué hacerlo. Las métricas offline a veces predicen bien los resultados online. En un estudio de comercio electrónico con 36 métricas offline, la mejor coincidió con los resultados online al decidir cuál de dos modelos de ranking era mejor, según una métrica de negocio, hasta en un 97 % de los casos (Wang et al., 2023). Otro equipo de comercio electrónico descubrió que las métricas offline de ranking "pueden mostrar una inconsistencia significativa con el rendimiento online, e incluso pueden ser engañosas" (Huzhang et al., 2020). Ambos son estudios de la industria sobre su propio tráfico, que nadie externo puede reproducir. Cuando dos sistemas rinden más o menos igual, distintas métricas suelen discrepar entre sí (Hofmann et al., 2016).

Las discrepancias tienen causas que puedes comprobar. Los juicios pueden no incluir productos que muestra el ganador online, algo que busca la prueba de sensibilidad. El cambio puede actuar fuera del ranking, en la velocidad o en el diseño. O bien la métrica online puede medir algo distinto del éxito. En un motor de búsqueda académico, Radlinski et al. (2008) comprobaron que los clics por consulta, como otras siete métricas absolutas de uso, no reflejaban de forma fiable la calidad de la recuperación con los tamaños de muestra que estudiaron.

La tienda puede simular una prueba A/B con el comprador navegacional de el ensayo de intercalado: 5,000 búsquedas con BM25 como control y 5,000 con recuperación semántica como tratamiento, todas con consultas de prueba. Mide los clics por búsqueda y la proporción de búsquedas con un clic en un producto exacto. Después repite con el usuario "perfecto" de la Tabla 2, el comprador perfecto, asignado de la misma forma, que lee los diez resultados, hace clic en todos los productos exactos y nunca abandona pronto. ¿Qué clasificador esperas que obtenga más clics por búsqueda, y estarían de acuerdo todos los compradores?

clicks-per-search-misleads.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Superado
"""Clicks per search and the share of searches with an exact click, for BM25 and semantic retrieval run as simulated A/B arms, for the navigational and the perfect shopper. The prose's point rests on the two 'reverses between shoppers' lines, read with the means and p-values printed before them."""import numpy as npfrom scipy import statsfrom lib.experiments import SHOPPERS, simulate_searchesfrom lib.lexical import LexicalSearchfrom lib.semantic import SemanticSearchfrom lib.store import load_products, load_queries, qrelsqueries, judgments = load_queries("test"), qrels("test")arms = {"bm25": LexicalSearch(load_products()).run(queries, k=100),     # control        "semantic": SemanticSearch().run(queries, k=100)}               # treatmentmetrics = {"clicks per search": "clicks", "share of searches with an exact click": "exact_click"}significant_leaders = {label: set() for label in metrics}      # rankers ahead at p below 0.05for shopper_name, shopper in SHOPPERS.items():                         # navigational, then perfect    # one seed per shopper: the two rankers draw from it in turn, bm25 first    rng = np.random.default_rng(2026)    searches = {name: simulate_searches(run, judgments, 5_000, rng, shopper) for name, run in arms.items()}    for label, column in metrics.items():        means = {name: table[column].mean() for name, table in searches.items()}        for name, mean in means.items():            print(f"{shopper_name} shopper, {name} {label}: {mean:.3f}")        # exact_click holds True and False; as floats they are 1 and 0 for the t-test        p = stats.ttest_ind(searches["semantic"][column].astype(float), searches["bm25"][column].astype(float)).pvalue        print(f"{shopper_name} shopper, {label} p: " + (f"{p:.3f}" if p >= 0.001 else "below 0.001"))        if p < 0.05:            significant_leaders[label].add(max(means, key=means.get))for label in metrics:    print(f"{label} reverses between shoppers:", "yes" if len(significant_leaders[label]) > 1 else "no")
Salidapython clicks-per-search-misleads.py
navigational shopper, bm25 clicks per search: 1.362
navigational shopper, semantic clicks per search: 1.269
navigational shopper, clicks per search p: below 0.001
navigational shopper, bm25 share of searches with an exact click: 0.695
navigational shopper, semantic share of searches with an exact click: 0.799
navigational shopper, share of searches with an exact click p: below 0.001
perfect shopper, bm25 clicks per search: 6.443
perfect shopper, semantic clicks per search: 7.451
perfect shopper, clicks per search p: below 0.001
perfect shopper, bm25 share of searches with an exact click: 0.898
perfect shopper, semantic share of searches with an exact click: 0.895
perfect shopper, share of searches with an exact click p: 0.646
clicks per search reverses between shoppers: yes
share of searches with an exact click reverses between shoppers: no

¿Se invierten los clics por búsqueda entre compradores? yes. Su signo depende de cómo se comporten los compradores, así que por sí solo no puede medir el éxito. El comprador de navegación obtiene 1.362 clics por búsqueda con BM25 y 1.269 con recuperación semántica, con un valor p de below 0.001, mientras que el comprador perfecto obtiene 7.451 con recuperación semántica frente a 6.443 con BM25. Un comprador que encuentra un producto exacto cerca de la parte superior hace clic en él y normalmente se va, mientras que otro al que se le muestran productos parciales hace clic en varios, buscando todavía.

¿Se invierte entre compradores la proporción de búsquedas con un clic exacto? no. Favorece a la recuperación semántica para el comprador de navegación, 0.799 frente a 0.695, y para el comprador perfecto no muestra una diferencia clara, con un valor p de 0.646, porque ese comprador hace clic en un producto exacto en 0.898 de las búsquedas con BM25 y en 0.895 de las de recuperación semántica, siempre que los 10 primeros contengan uno.

Una única respuesta para todos los compradores convertiría los clics en una medida de calidad. Miden el comportamiento, y el comportamiento varía.

Regla práctica: Cuando los resultados offline y online no coinciden, encuentra la causa antes de confiar en ninguno de los dos. Comprueba que la métrica online mida el éxito, como una compra, y no la actividad. Revisa judged@10 en los resultados del ganador online y juzga qué falta. Luego decide según el resultado online de la métrica que elegiste de antemano, y añade consultas o juicios al conjunto de regresión para que prediga mejor la próxima vez.

Decidir si lanzar

Último cambio en la edición 2026.11.8

La decisión de lanzar combina las comprobaciones offline y online. Escribe la lista de verificación antes de ver cualquier resultado, para que ningún número solo pueda convencerte de hacer un cambio. Recomendamos estos puntos, cada uno con la sección que lo muestra:

  1. Una mejora offline establecida en el conjunto de regresión, según la regla de comparación planificada, con su prueba t e intervalo (diferencia por consulta), frente al sistema más fuerte que tengas. Armstrong et al. encontraron que, durante una década de mejoras publicadas en las colecciones de TREC, "Baselines are generally weak, often being below the median original TREC system" (Armstrong et al., 2009).
  2. Pérdidas revisadas, y URisk con α = 1 no negativo (URisk).
  3. Juicios que cubran ambas ejecuciones: un líder que se mantenga cuando los productos sin juzgar de cualquiera de las dos ejecuciones cuenten como exactos, o nuevos juicios cuando no se mantenga (productos sin juzgar).
  4. Calificaciones humanas para las puntuaciones principales de los rankers basados en LLM (capítulo 4).
  5. Latencia y costo dentro del presupuesto (capítulo 9).
  6. Cada ajuste elegido con consultas de entrenamiento, y cada revisión de las consultas de prueba registrada (consultas held-out).
  7. Un plan online escrito de antemano: la métrica principal y las salvaguardas, el tamaño según un cálculo de potencia, una prueba A/A, una comprobación de la proporción de muestra y sin mirar los resultados antes de tiempo (prueba A/B). El interleaving puede filtrar primero los candidatos (team draft).

Toma los tres primeros puntos para el cambio de la tienda a la recuperación semántica. El punto 1 exige una mejora establecida, y la prueba de permutación responde yes, con un cambio medio de 0.105 y un intervalo del 95% de 0.055 to 0.185. El punto 2, URisk con α = 1, es 0.092.

Punto 3, juicios que cubran ambas ejecuciones: si todos los productos sin juzgar de BM25 fueran exactos, BM25 obtendría 0.788 y la recuperación semántica 0.829. ¿Cambia el líder? no. Los puntos online esperan a que haya tráfico.

Regla práctica: Lanza cuando todos los puntos offline se cumplan y la prueba online, dimensionada de antemano, muestre una mejora significativa en la métrica principal sin ninguna salvaguarda peor. Cuando falle un punto offline, corrígelo antes de pasar a online, porque las pruebas online consumen el tiempo de los compradores. Cuando la prueba online no sea concluyente con su tamaño planificado, conserva la línea base.

Qué sale mal en producción

Último cambio en la edición 2026.11.8

Una tienda prueba un cambio tras otro con tráfico real, con compradores reales en lugar de simulados, y el mismo conjunto de regresión en cada paso.

El panel invita a mirar antes de tiempo. Una plataforma de experimentos muestra resultados cada día, y un equipo que se detiene la primera vez que un resultado parece significativo obtiene muchos más falsos positivos que el 5 %, como muestra la simulación A/A. Fija el tamaño de antemano, o usa un método secuencial.

Los grupos no coinciden con el plan. Fabijan et al. reunieron en una taxonomía las causas de las discrepancias en la proporción de muestra de varias empresas. Revisa la división antes de leer cualquier resultado, y no confíes en el resultado hasta que sepas por qué la división está desviada.

El conjunto de regresión se desgasta. Cada decisión tomada mirando las consultas de prueba consume parte de su independencia (Dwork et al., 2015). Registra cada revisión, y actualiza el conjunto de prueba con consultas y juicios nuevos cuando el registro crezca demasiado.

Un juez LLM se convierte en la puerta de control. Los juicios de un LLM son lo bastante baratos como para puntuar cada candidato. Otero et al. hallaron que las pruebas de significancia sobre juicios de un LLM mostraban «una tasa excepcionalmente alta de falsos positivos en cuanto a diferencias estadísticas» (Otero et al., 2025). Antes de publicar una mejora medida por un LLM, confírmala con juicios humanos (capítulo 4).

Los empates mueven los resultados. Los productos con puntuaciones iguales aparecen en el orden que deje la selección de una biblioteca (capítulo 3), así que un cambio que no toca ninguna puntuación aún puede mover un resultado. ¿Cambia el veredicto de interleaving de 100 búsquedas de la tienda si se invierten los empates de BM25? yes. Desempata por un ID en cada ranker, y vuelve a ejecutar un resultado cercano a su umbral con los empates invertidos antes de actuar sobre él.

El interleaving no puede ver la página completa. Creemos que un ranker más lento, o que cambie cuántos resultados aparecen, puede ganar una prueba con interleaving y aun así perder compradores. Ejecuta una prueba A/B para cambios como estos.

Regla práctica: Automatiza en la plataforma de experimentos la prueba A/A, la comprobación de la proporción de muestra y el tamaño fijo de la prueba, lleva un registro de cada revisión de las consultas de prueba, desempata por un ID, y confirma las mejoras medidas por un LLM con juicios humanos.

Decisiones que tomó este capítulo

Último cambio en la edición 2026.11.8

La razón de cada valor por defecto está en la sección a la que enlaza.

  • El conjunto de regresión son los 30 consultas de prueba con sus juicios, y cada elección usa las 50 consultas de entrenamiento (consultas reservadas).
  • Una comparación planificada sobre las consultas de prueba: la recuperación semántica frente a BM25, establecida solo por un valor p de permutación inferior a 0.05, junto con la prueba t y un intervalo del 95 % (diferencia por consulta). El ranker de 128 dimensiones es exploratorio, elegido por cómo se comporta en la prueba (URisk).
  • Cada candidato recibe una diferencia por consulta, y sus pérdidas se leen a mano.
  • URisk usa α = 1, de modo que cada pérdida cuenta doble. Es un juicio sobre cuánto cuesta una regresión, y una tienda con fallos costosos debería aumentar este valor (URisk).
  • Cuando el líder cambia entre los dos escenarios sin juzgar, juzga antes de comparar, y conserva los nuevos juicios en el conjunto de regresión (productos sin juzgar).
  • Las consultas de prueba se miran una vez por decisión, y cada revisión se registra (consultas reservadas).
  • Las pruebas A/B se dimensionan con 16σ²/Δ² antes de empezar, se leen una sola vez a ese tamaño y van precedidas por una prueba A/A y una comprobación de la proporción de muestra (potencia).
  • El intercalado usa team draft y una prueba de signos (team draft).
  • Los compradores simulados siguen un modelo de cascada de navegación asignado a tres grados, con frecuencia uniforme de consultas, probabilidades declaradas como supuestos en lib.experiments y una semilla fija para cada simulación. Sus veredictos ensayan un método y nunca cuentan como evidencia (ensayo).
  • Los clics por búsqueda no son por sí solos una métrica de éxito. Usa una medida de éxito, como una compra (sin conexión y en línea).
  • Lo que mostró el capítulo: decide qué te haría cambiar de opinión antes de mirar, y luego mira una sola vez.

Este capítulo, en esta edición

Edición 2026.11.10Ejemplos verificados el 19 de nov de 2026Superan la prueba 11 de 11 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 11 de 11: Pruebas de los cambios

  1. Comparar dos ejecuciones consulta por consulta
  2. Pondera las pérdidas más que las ganancias con URisk
  3. Juzga los productos que un nuevo ranker muestra
  4. Mantén las consultas de prueba fuera de cada elección
  5. Ejecutar una prueba A/B
  6. Dimensionar la prueba con potencia
  7. Interleaving de dos rankings con team draft
  8. Ensayar el interleaving con compradores simulados
  9. Encuentra la causa cuando lo offline y lo online no coinciden
  10. Decidir si lanzar
  11. Qué sale mal en producción
  12. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos