Testando mudanças

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

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

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

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

Ao final deste capítulo, você poderá decidir se uma mudança na busca deve ser lançada: comparar, consulta por consulta, os resultados de dois ranqueadores; manter as suas consultas de teste sem que elas favoreçam uma mudança; dimensionar um teste A/B; e comparar dois ranqueadores por meio do intercalamento dos seus resultados.

A loja acompanhada por este livro, um varejista online de móveis e artigos para casa (capítulo 1), ainda usa BM25 na sua caixa de busca como referência de base. O trabalho offline dos capítulos anteriores deu à recuperação semântica uma vantagem consolidada sobre o BM25 (capítulo 3). Trocar de método é uma mudança, e também é cada ajuste que vem depois: um embedding mais barato, um peso de mistura, um reranker. Cada mudança levanta as mesmas quatro perguntas. A média subiu, e além do ruído? Quais consultas pioraram? Os julgamentos conseguem pontuar os novos resultados? Os compradores vão se comportar como os julgamentos preveem? Este capítulo responde a essas perguntas nessa ordem. As 30 consultas de teste da loja se tornam o seu conjunto de regressão, ou seja, as consultas fixas com as quais toda mudança é testada, e todas as escolhas são feitas com base nas suas 50 consultas de treino. A loja não tem logs de click, então as seções online simulam compradores, e as premissas de cada simulação são declaradas ao lado dela.

O capítulo planeja uma comparação nas consultas de teste: recuperação semântica contra BM25. Seguindo o capítulo 3, uma comparação planejada mantém todo o nível de 0.05 do livro, de modo que uma diferença só é considerada estabelecida abaixo de 0.05 aqui. Todas as demais pontuações nas consultas de teste deste capítulo são exploratórias.

Compare duas execuções consulta por consulta

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

As duas primeiras perguntas, se a média subiu e quais consultas pioraram, são respondidas em um conjunto de regressão: consultas fixas, com julgamentos, contra as quais toda mudança é executada antes de ser lançada. O ranqueador que a loja executa hoje é o baseline, e o ranqueador com a mudança é o ranqueador candidato. Cada um produz uma execução, isto é, seus rankings para cada consulta do conjunto. Comparar apenas as médias das execuções não basta, porque uma mudança pode elevar a média e, ainda assim, piorar algumas consultas. O TREC, as avaliações conjuntas de sistemas de busca da Text REtrieval Conference, criou uma tarefa em torno desse risco em sua trilha Web de 2013, pontuando as vitórias e derrotas de cada sistema por consulta em relação a um baseline (Collins-Thompson et al., 2014). Por isso, compare as duas execuções: uma linha por consulta, com a pontuação do baseline, a pontuação do candidato e a variação. Depois, conte as vitórias, derrotas e empates, e leia as derrotas.

O baseline é o BM25 e o candidato é a recuperação semântica, ambos pontuados com nDCG@10 nas consultas de teste. O exemplo monta a comparação com pandas, e seus testes vêm de lib.significance, que o capítulo 3 constrói à mão. Esses testes são um teste de permutação e um teste t pareado. Ao lado deles, há um intervalo bootstrap, no nível de confiança que corresponde ao limiar. O bootstrap e o teste de permutação reamostram ao acaso, por isso lib.significance fixa a semente do SciPy com 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 Aprovado
"""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())
Saídapython 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

A recuperação semântica eleva a média de nDCG@10 de 0.725 para 0.830, uma variação de 0.105. Com o limiar de 0.05, o teste de permutação dá 0.001. A mudança está estabelecida? yes. Ao lado dele, o teste t pareado dá 0.003, e o intervalo de 95% vai de 0.055 to 0.185.

É nas derrotas que você aprende algo. A recuperação semântica vence em 21 consultas, perde em 7 e empata em 2, e sua maior derrota é -0.092. Duas das derrotas trazem uma medida em polegadas, 48 inch kitchen hood e 48" sliding single track , barn door for laundry: são duas consultas, não um padrão. O capítulo 6 testa o padrão em todas as consultas que têm algum dígito.

Regra prática: Mantenha um conjunto de regressão de consultas julgadas nas quais nada nunca é ajustado, e execute cada candidato contra o baseline nele. Liste primeiro suas comparações planejadas, e relate cada uma com seu valor-p da permutação, seu teste t e seu intervalo. Conte vitórias, derrotas e empates, e leia cada derrota antes de lançar. Quando as derrotas parecerem compartilhar um padrão, verifique-o nas consultas de treino antes de agir sobre ele, e então corrija esse tipo de consulta ou envie-a ao baseline.

Dê mais peso às perdas do que aos ganhos com o URisk

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

A diferença por consulta conta as perdas, mas a mudança média ainda trata uma consulta que piorou 0.1 e outra que melhorou 0.1 como se uma anulasse a outra. Uma loja pode não enxergar assim: um cliente que encontrou um produto ontem e não consegue encontrá-lo hoje sofreu uma regressão, e um ranqueamento um pouco melhor em outros casos não compensa isso. A avaliação sensível a risco conta as perdas com mais peso do que os ganhos.

A medida sensível a risco da trilha Web do TREC 2013 é o URisk. Para cada consulta q, seja Δ(q) a pontuação do candidato menos a pontuação da base. Some os ganhos nas consultas que melhoraram, subtraia as perdas nas consultas que pioraram, contadas α + 1 vezes, e divida pelo número de consultas N:

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

A trilha descreve isso como "ponderar as perdas α + 1 vezes mais do que os sucessos", e α = 0 dá a mudança média simples (Collins-Thompson et al., seção 4.3). A visão geral da trilha escreve o termo de perda com o próprio Δ(q), que é negativo em uma consulta prejudicada. Usamos o seu tamanho, |Δ(q)|, a única leitura sob a qual α = 0 dá a média, como diz a visão geral. α é uma escolha, não um fato. Usamos α = 1, de modo que cada perda conta em dobro.

Compare dois candidatos com o BM25. O primeiro é a recuperação semântica completa, com todos os 768 números de cada embedding de Snowflake/snowflake-arctic-embed-m-v1.5. O segundo mantém apenas os primeiros 128 números, um sexto da memória. Isso fica abaixo das 256 dimensões documentadas no cartão do modelo, e o capítulo 6 rejeitou 128 nas consultas de treino. Usamos esse valor porque, nas consultas de teste, ele troca ganhos em algumas consultas por perdas em outras, e é exatamente para isso que o URisk serve. Escolhido pelo comportamento no teste, ele é exploratório, não uma comparação planejada. O URisk cabe em algumas linhas; execute-o nos dois 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 Aprovado
"""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}")
Saídapython 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

A mudança média da recuperação semântica completa é 0.105, e o seu URisk é 0.092. As suas perdas, 7, são pequenas, sendo a maior -0.092, de modo que dobrá-las custa pouco.

A mudança média do ranqueador mais barato é 0.017, mas, com as perdas contadas em dobro, o seu URisk é -0.033. Ele vence em 15 consultas e perde em 13, e a sua maior perda é -0.253. A média oculta essa troca: resultados melhores em algumas consultas, pagos com resultados piores em outras.

O seu teste de permutação dá 0.592, o teste t pareado dá 0.597, e o intervalo de 95% vai de -0.036 to 0.088.

Algumas das perdas podem ser de produtos que ninguém avaliou, já que o seu judged@10 é 0.920, contra 0.927 do BM25 e 0.990 da recuperação semântica completa. A seção seguinte verifica isso.

O URisk descreve o risco sem testá-lo. Dinçer et al. definem uma medida relacionada, o TRisk, que "é uma transformação linear da estatística t", de modo que pode ser testada como o teste t pareado (Dinçer et al., 2014).

Regra prática: Informe o URisk com α = 1 ao lado da mudança média de cada candidato. Não coloque em produção um candidato cujo URisk seja negativo, qualquer que seja a sua média, e leia as suas perdas para descobrir o motivo. Aumente α quando as falhas forem caras, e informe o URisk separadamente para as consultas mais frequentes da loja. Use α = 0 somente quando uma perda em uma consulta não for pior do que um ganho em outra.

Julgue os produtos que um novo ranqueador retorna

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

As perdas de um novo ranqueador, como as do ranqueador mais barato no exemplo da URisk, podem vir de lacunas nos julgamentos, que cobrem apenas os produtos que os sistemas anteriores encontraram. O WANDS, fonte dos julgamentos da loja, julgou apenas o que os sistemas anteriores haviam encontrado (capítulo 2). Um ranqueador diferente deles retorna produtos que ninguém julgou, e as métricas atribuem a cada um deles nota 0; portanto, a pontuação pode estar baixa demais ou estar exatamente certa. Você só descobre qual das duas situações vale quando alguém julga esses produtos. Os autores do WANDS alertam que lacunas desse tipo enfraquecem a avaliação: "a incompletude no conjunto de dados de Product Search afeta negativamente o poder discriminativo da avaliação" (Chen et al., 2022).

O capítulo 2 conta os produtos não julgados com judged@10. Para testar uma mudança, um passo a mais ajuda: uma verificação de sensibilidade, que recalcula a pontuação das duas execuções sob dois cenários, cada um favorecendo um dos lados. No primeiro, todo produto não julgado nos top 10 da linha de base é considerado exato; no segundo, todo produto não julgado nos top 10 do candidato. As duas execuções são pontuadas com os mesmos julgamentos em cada cenário, porque o ideal do nDCG é construído a partir de todos os julgamentos da consulta: um produto julgado como exato eleva o ideal e, por isso, reduz a pontuação de toda execução que não o exibe. Os cenários não são limites, pois os julgamentos verdadeiros podem misturar os dois casos. Se o líder mudar entre eles, os julgamentos ainda não podem decidir a comparação.

A recuperação semântica mais barata do exemplo da URisk, que mantém 128 dos 768 números de cada embedding, perdeu 13 das consultas de teste da loja para o BM25. Antes de tirar qualquer conclusão dessas perdas, execute a verificação:

unjudged-score-range.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""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"])))
Saídapython 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

O líder muda? yes. Portanto, os julgamentos ainda não podem resolver a comparação. Conforme julgado, o ranqueador mais barato lidera, 0.742 a 0.725.

Se os produtos não julgados do BM25 fossem exatos, o BM25 lideraria, 0.788 a 0.738. Se os produtos não julgados do ranqueador mais barato fossem exatos, ele lideraria, 0.807 a 0.718.

Os top 10 do BM25 contêm 22 pares não julgados, e os do ranqueador mais barato contêm 24. A comparação depende de 46 julgamentos, uma conta pequena perto do custo de implantar o ranqueador errado.

Não tente adivinhar o que os avaliadores dirão. Em uma coleção antiga do TREC, Voorhees et al. julgaram novos conjuntos de documentos reunidos a partir de execuções neurais e do BM25, e constataram que a grande maioria dos novos documentos não era relevante (Voorhees et al., 2022). Mas essa coleção foi reunida de forma profunda, a partir de muitos sistemas, e o WANDS foi construído de outra maneira. Julgamentos humanos são a referência. Julgamentos feitos por um modelo de linguagem de grande porte (LLM) são mais baratos. O capítulo 4 preenche os pares não julgados da loja com esses julgamentos, como um diagnóstico, e pede que pessoas julguem os pares sempre que as notas preenchidas mudarem um veredito ou a ordem de dois ranqueadores. Thomas et al. levantam um risco que importa ao testar mudanças: rótulos produzidos por um LLM podem favorecer ranqueadores que também usam um LLM (Thomas et al., 2024).

Regra prática: Para cada candidato, calcule judged@10 para as duas execuções e recalcule a pontuação sob os dois cenários. Quando o líder mudar, julgue os pares não julgados antes de comparar, e acrescente os novos julgamentos ao conjunto de regressão de forma definitiva, para que ele cubra todos os ranqueadores que você testou. Quando o líder se mantiver nos dois cenários, é improvável que os produtos não julgados revertam a comparação.

Mantenha as consultas de teste fora de toda escolha

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

As consultas de teste do conjunto de regressão são reservadas, e consultas reservadas dão uma pontuação honesta somente se nada foi escolhido olhando para elas. Treinar com consultas de teste é o erro óbvio. Escolher com base nelas é o erro sutil: testam-se várias configurações, mantém-se a que pontua melhor nelas e relata-se essa pontuação. O vencedor é em parte a melhor configuração e em parte a mais sortuda nessas consultas específicas, de modo que sua pontuação fica alta demais. Dwork et al. afirmam o risco: "Reutilizar um conjunto de retenção de forma adaptativa, várias vezes, pode facilmente levar a sobreajuste ao próprio conjunto de retenção" (Dwork et al., 2015). O dano pode ser menor do que se teme. Quando o conjunto de teste do ImageNet foi refeito, os classificadores perderam acurácia, mas os resultados de Recht et al. sugerem que a adaptatividade não causa essas quedas: as novas imagens eram mais difíceis (Recht et al., 2019). Em nossa avaliação, um conjunto de 30 consultas deixa pouco espaço, e cada olhada conta.

A mudança é uma mistura de recuperação BM25 e recuperação semântica com um único peso, a parcela dada à recuperação semântica. O Capítulo 7 chama esse peso de α, um α diferente do de URisk, e o ajusta nas consultas de treino com fusão de rank recíproco ponderada, sobre 0, 0.1, … 1. Escolha o peso semântico das duas formas, a certa nas consultas de treino e a errada nas consultas de teste, e relate cada escolha nas consultas de teste. Essas pontuações de teste mostram o viés; elas são exploratórias, não uma comparação planejada. Em seguida, meça quanto escolher com base nas consultas relatadas infla a pontuação delas, sem tocar de novo nas consultas de teste: divida as consultas de treino ao acaso, 1,000 vezes, em 30 para escolher e 20 para relatar, e compare a pontuação das 20 consultas relatadas quando o peso é escolhido nas 30 com a pontuação delas quando o peso é escolhido nas próprias 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 Aprovado
"""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}")
Saídapython 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

Escolher o peso nas consultas de teste favorece a mistura. Escolhido nelas, o peso semântico é 0.8, e a mistura pontua 0.835.

Escolhido no treino, ele é 0.6, e a mistura pontua 0.825 nas consultas de teste, contra 0.830 da recuperação semântica sozinha. Somente essa pontuação escolhida no treino estima de forma justa o desempenho da mistura em consultas nas quais ela não foi escolhida. O Capítulo 7 testa a mistura escolhida no treino contra a recuperação semântica e não encontra melhora.

As divisões aleatórias quantificam o viés. Em conjuntos de relatório de 20 consultas, escolher com base nas consultas que você relata acrescenta 0.007 ao nDCG@10 em média, com 11 configurações para escolher. Esse ganho aparece no relatório e em mais nenhum lugar. Cada configuração extra que você testa é mais uma chance de um vencedor sortudo.

Regra prática: Escolha todas as configurações com consultas de treino, inclusive qual candidato levar adiante. Olhe para as consultas de teste uma vez por decisão e registre cada olhada: o que foi comparado e o que foi escolhido. Quando um conjunto de teste tiver orientado muitas decisões, passe-o para o lado do treino e avalie um conjunto novo de consultas de teste.

Execute um teste A/B

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

Testes offline medem rankings contra julgamentos, mas a loja ganha com os clientes. Um teste A/B, ou experimento controlado, atribui usuários aleatoriamente ao sistema atual ou à mudança, e compara uma métrica escolhida antes de o teste começar (Kohavi et al., 2009). O sistema atual é o controle, e o sistema alterado é o tratamento.

Três verificações tornam o resultado confiável. Primeiro, um teste A/A, no qual os dois grupos recebem o mesmo sistema, deveria rejeitar a hipótese nula cerca de 5% das vezes, com nível de confiança de 95% (Kohavi et al., 2009). Muito mais que 5% indica uma configuração defeituosa. Segundo, leia o resultado uma única vez, no tamanho que você planejou. Encerrar um teste no momento em que ele parece significativo, chamado espiada, infla consideravelmente a taxa de erro do tipo I (Kohavi et al., 2022). Terceiro, verifique se os grupos ficaram do tamanho planejado. Um descasamento da razão de amostras (SRM, do inglês sample ratio mismatch) significa que usuários desapareceram de um grupo ou foram acrescentados a ele de forma desigual, e "Ignorar o SRM sem conhecer a causa raiz pode resultar em uma modificação ruim do produto aparentando ser boa" (Fabijan et al., 2019).

Para uma métrica de conversão, a proporção de clientes que compram, o teste compara duas proporções. Com taxas p_A e p_B sobre n clientes em cada grupo, e p̄ a média delas:

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

Simule 2,000 testes A/A sob premissas declaradas, para ver o efeito da espiada: 2,000 clientes por dia em cada grupo, 5% compram, e cada teste planejado para 14 dias. Leia cada um no final planejado, e também a cada dia, interrompendo no primeiro valor-p abaixo de 0.05. Depois, verifique uma divisão quanto a descasamento da razão de amostras.

aa-tests-with-peeking.py Python 3.12.15 · numpy 2.5.5 · scipy 1.18.1 Aprovado
"""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")
Saídapython 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

Verificar todos os dias faz com que muito mais testes A/A pareçam significativos. Lidos no final planejado, a proporção que resulta significativa é 0.053, próxima dos 0.05 que o limiar promete. Verificados diariamente, a proporção que parece significativa em algum dia sobe para 0.231, embora a busca de nenhum dos grupos tenha mudado. Para uma divisão planejada em 50/50 que resulta em 28,000 para 27,100, um teste binomial de 27,100 em 55,100 clientes contra metade gera um valor-p below 0.001: o acaso quase nunca produz uma diferença desse tamanho.

Um valor-p é frequentemente mal interpretado: 0.05 não significa uma chance de 5% de que o resultado seja um falso positivo; Kohavi et al. (2022) chamam isso de "um equívoco muito comum". Ele é a probabilidade de dados pelo menos tão extremos quanto estes, se a mudança não tivesse efeito algum.

Regra prática: Antes do teste, escolha a métrica primária e as métricas de proteção que não podem piorar, e dimensione o teste (com poder estatístico). Execute primeiro um teste A/A na mesma configuração. Verifique a razão de amostras antes de ler qualquer resultado, e leia o resultado uma única vez, no tamanho planejado. Se precisar acompanhar um teste enquanto ele roda, use um método sequencial feito para monitoramento contínuo, como valores-p sempre válidos (Johari et al., 2015).

Dimensione o teste com poder estatístico

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

Ler um teste A/B uma vez, no tamanho planejado, significa planejar esse tamanho antes, a partir do poder do teste: a chance de que ele detecte uma mudança real de determinado tamanho. Um teste com pouco poder deixa passar mudanças reais e, quando sai significativo, tende a exagerar: "um resultado estatisticamente significativo com baixo poder provavelmente exagera muito o tamanho do efeito" (Kohavi et al., 2022). Por isso, decida o tamanho antes de o teste começar, a partir de dois números: quanto a métrica varia entre usuários e a menor mudança que vale a pena detectar. Mais variância exige mais usuários. Uma mudança menor exige muito mais, porque a mudança entra elevada ao quadrado.

Para dois grupos, 95% de confiança e 80% de poder, Kohavi et al. dão uma regra empírica, com σ² a variância da métrica e Δ a mudança a detectar (Kohavi et al., 2009):

users per group ≈ 16 × σ² / Δ²

O 16 vem da distribuição normal: 2 × (z para 97.5% + z para 80%)², cerca de 2 × (1.96 + 0.84)². Para 90% de poder, eles trocam 16 por 21. O SciPy calcula o coeficiente, e o código confere a regra com os dois exemplos trabalhados do artigo: receita por usuário, com média de $3.75 e desvio padrão de $30, e taxa de conversão de 5%, cada um com uma mudança relativa de 5% a detectar. Os dados da loja, do WANDS, não têm valores de vendas, então o código supõe que a loja também converte 5%.

sample-size-from-power.py Python 3.12.15 · scipy 1.18.1 Aprovado
"""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}")
Saídapython 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

Reduza a mudança à metade e você precisa de quatro vezes mais usuários: com a conversão de 5% presumida para a loja, uma mudança de 2% exige 760,000 usuários por grupo, e uma mudança de 1% exige 3,040,000.

O coeficiente é 15.7, e os exemplos de receita e de conversão precisam de 409,600 e 121,600 usuários por grupo, o que confere com os números do artigo, de mais de 409,000 e menos de 122,000.

A mesma aritmética mostra o que o conjunto de regressão consegue detectar. Como os dois rankers pontuam as mesmas consultas, o teste trabalha com uma amostra única de diferenças por consulta, em vez de dois grupos, e o coeficiente cai pela metade, para 7.8. Tome σ como a dispersão dessas diferenças entre dois rankers próximos: a recuperação semântica e a execução híbrida que a combina com o 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 Aprovado
"""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")
Saídapython 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

As mudanças por consulta têm uma dispersão de 0.062, então, com 30 consultas de teste, o conjunto de regressão detecta uma mudança de 0.032 em nDCG@10 com 80% de poder. Uma mudança de 0.01 exigiria 300 consultas.

scipy.stats.power confere a aritmética por simulação, sorteando diferenças com distribuição normal: nessa mudança, o teste t pareado tem um poder simulado de 0.779. Isso fica abaixo do 0.8 planejado? yes, porque a fórmula usa a distribuição normal, enquanto o teste t, nas consultas de teste, usa a distribuição t, que é mais larga. As diferenças reais não são normais, então a simulação confere a fórmula, não os dados. Ao acrescentar consultas, acrescente muitas e julgue cada uma superficialmente: Webber et al. observaram que, para o mesmo esforço de julgamento, muitas consultas julgadas superficialmente dão mais poder estatístico do que poucas julgadas em profundidade (Webber et al., 2008).

Regra prática: Dimensione todo teste A/B antes de ele começar. Se ele precisar de mais usuários do que a loja recebe em algumas semanas, teste uma mudança maior, use uma métrica que varie menos ou ajuste a métrica com os dados de cada usuário de antes do teste. Nos experimentos do Bing, Deng et al. relatam que isso "pode reduzir a variância em cerca de 50%" (Deng et al., 2013); quanto isso economiza depende de quão bem o comportamento passado de um usuário prevê a métrica. Offline, calcule a menor mudança que o seu conjunto de regressão consegue detectar e acrescente consultas quando as suas mudanças forem menores. Fixe o número com antecedência: acrescentar consultas até que uma estimativa de poder diga que há o suficiente enviesa você a encontrar significância (Webber et al.).

Intercale dois rankings com team draft

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

Um teste A/B mostra a cada grupo um ranking diferente, então as diferenças entre compradores acrescentam ruído. Intercalação (interleaving) mostra a cada comprador uma única lista que mistura os resultados de dois ranqueadores. Joachims a projetou para que "a ordenação combinada dê (quase) igual viés de apresentação aos dois mecanismos de busca" (Joachims, 2003): nenhum dos ranqueadores tem seus produtos sistematicamente mais acima. O ranqueador cujos produtos recebem mais click vence aquela busca. A intercalação responde a uma pergunta mais restrita que o teste A/B: qual de dois rankings os usuários preferem, e não um número absoluto para nenhum dos dois (Hofmann et al., 2016).

Team draft intercala as listas de dois ranqueadores como quem escolhe times para um jogo (Radlinski et al., 2008, Algoritmo 2). O time com menos escolhas escolhe em seguida, e um sorteio por moeda decide quando os dois têm o mesmo número. Cada escolha é o produto mais bem ranqueado pelo time que ainda não foi exibido. Um click conta para o time que escolheu o produto. Radlinski et al. mostram que, sob o team draft, "um usuário que clica ao acaso sempre produzirá, em expectativa, o mesmo número de preferências por A e por B", o que um método anterior não garantia.

Intercale a busca semântica da loja com o BM25 para a consulta de teste clear shower curtain. O team draft cabe em poucas linhas, com um gerador de números aleatórios de semente fixa para os sorteios por moeda, e o código verifica que lib.experiments retorna a mesma 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 Aprovado
"""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")
Saídapython 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

O team draft sempre dá a cada ranqueador 5 posições de uma lista de dez; os sorteios decidem quais posições. Um produto que os dois ranqueadores colocam no alto aparece uma única vez, creditado ao time que o escolheu primeiro, de modo que nenhum ranqueador recebe crédito duplo pelo mesmo produto. Para esta consulta, um dos ganchos para cortina de box que o BM25 ranqueia (capítulo 1) entra, no final da lista, como a última escolha do BM25. Os clicks do comprador nas escolhas da busca semântica contam para a busca semântica, os clicks nas escolhas do BM25 contam para o BM25, e o time com mais clicks vence a busca.

Regra prática: use a intercalação com team draft para comparar, online, dois ranqueadores quando precisar saber qual deles os usuários preferem, com menos buscas do que exigiria um teste A/B. Use um teste A/B quando precisar de um número absoluto, como a receita, ou quando a mudança não estiver no ranking. Pelo nosso raciocínio, uma lista intercalada não consegue mostrar o efeito da latência, do layout da página ou de um número diferente de resultados.

Ensaie o interleaving com compradores simulados

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

O WANDS, fonte dos dados da loja, não tem cliques, então a loja não consegue rodar o team-draft interleaving com compradores reais, mas pode ensaiar com compradores simulados. Um modelo de clique é um modelo probabilístico de como os usuários percorrem e clicam em uma lista de resultados, usado tanto para construir métricas quanto para simular usuários (Chuklin et al., 2015). O modelo cascata diz que os usuários leem do topo e "saem assim que veem um documento que vale a pena" (Craswell et al., 2008; veja o capítulo 2). A simulação padrão segue esse modelo: sorteia uma consulta ao acaso, com a mesma probabilidade para todas, percorre a lista dela, clica em cada produto com uma probabilidade que depende da sua nota e, depois de um clique, sai com outra probabilidade que depende da nota (Oosterhuis and de Rijke, 2018). A pesquisa sobre interleaving testa seus métodos desse modo, com cliques simulados a partir de dados rotulados (Hofmann et al., 2011).

As probabilidades são suposições. A Tabela 2 de Oosterhuis e de Rijke traz um usuário "navegacional" para cinco notas, um que busca um único resultado altamente relevante, que chamamos de comprador navegacional. Mapeamos irrelevante, parcial e exato para as notas mais baixa, intermediária e mais alta desse usuário, contamos produtos não avaliados como irrelevantes, como fazem as métricas, e sorteamos cada consulta com a mesma frequência. Os valores ficam em um só lugar, lib.experiments:

Nota Clique Parar após o clique
Exato 0.95 0.9
Parcial 0.5 0.5
Irrelevante 0.05 0.2

Envie um desses compradores pela lista do team-draft para clear shower curtain, à mão:

one-simulated-shopper.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""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")
Saídapython 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

Os cliques do comprador contam 1 para a busca semântica e 1 para o BM25, então o veredito desta busca é neither, a tie. Simule 10,000 buscas intercaladas, com uma semente fixa, para dois pares: busca semântica contra BM25, e o run híbrido contra a busca semântica. Um teste de sinal pergunta se as vitórias superam as derrotas por mais do que o acaso; Radlinski et al. usam "um teste de sinal binomial", deixando os empates de fora. Leia o veredito com 100, 1,000 e 10,000 buscas:

simulated-interleaving-verdict.py Python 3.12.15 · bm25s 0.3.16 · numpy 2.5.5 · pandas 3.1.1 · scipy 1.18.1 Aprovado
"""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")
Saídapython 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

Amostras pequenas oscilam. Para a busca semântica contra o BM25, uma grande diferença offline, o veredito indica 51 wins, 36 losses, p 0.133 com 100 buscas e 519 wins, 347 losses, p below 0.001 com 1,000. Para o híbrido contra a busca semântica, indica 32 wins, 51 losses, p 0.048 com 100 buscas e 413 wins, 447 losses, p 0.260 com 1,000, e por isso você fixa o número de buscas antes de o teste começar.

Com 10,000 buscas, o veredito do híbrido indica 4180 wins, 4593 losses, p below 0.001. Isso não derruba a conclusão do capítulo 3 de que não há diferença estabelecida: com cada vez mais cliques simulados sobre as mesmas 30 consultas de teste, o teste de sinal mede apenas ruído de cliques, e qualquer diferença fixa se torna significativa.

O veredito do híbrido com 100 buscas também depende de um detalhe que não carrega informação. O híbrido funde o BM25, e lib.lexical ordena pontuações BM25 iguais por product_id. Ordene-os de outro jeito, por uma regra igualmente arbitrária, e a mesma semente indica 35 wins, 48 losses, p 0.187 com 100 buscas. O veredito em 0.05 muda? yes. Inverter os empates do BM25 altera algumas listas do híbrido, então os compradores simulados veem outros produtos, e cada sorteio aleatório depois da primeira lista alterada pode se alterar. Um veredito que uma regra de desempate pode inverter é sorte, não uma conclusão sobre os rankers.

Três limites mantêm isto como um ensaio. Os cliques vêm das mesmas notas que o nDCG@10 usa, então o interleaving tende a concordar com o nDCG@10; ele não acrescenta evidência sobre os rankers. Toda busca vem das mesmas 30 consultas, então o teste de sinal vale apenas para essas consultas. E compradores reais não são esse modelo. Deffayet et al. estudaram o que acontece quando muda o ranker que produziu um registro de cliques, e constataram que os modelos de clique são sensíveis a essa mudança (Deffayet et al., 2023). Em tráfego real, em três buscadores, o interleaving concordou com os julgamentos de especialistas sempre que ambos eram significativos, e precisou de "aproximadamente 1–2 ordens de grandeza menos dados do que as métricas absolutas" (Chapelle et al., 2012). Pelo nosso raciocínio, a simulação não consegue mostrar essa vantagem, porque todos os seus compradores se comportam do mesmo jeito.

Regra prática: Ensaie um teste de interleaving em simulação para verificar seu código e seu teste de sinal. Trate qualquer contagem de buscas que ela sugira como tão boa quanto o comprador suposto, e rode de novo um veredito simulado com os empates desfeitos na ordem contrária antes de tirar qualquer conclusão. Nunca apresente um veredito simulado como evidência sobre um ranker. Em tráfego real, fixe o número de buscas com antecedência e decida com um teste de sinal.

Descubra a causa quando o offline e o online discordam

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

Compradores simulados clicam segundo as mesmas notas que o nDCG@10 usa, por isso tendem a concordar com ele; compradores reais não precisam fazer o mesmo. Métricas offline às vezes preveem bem os resultados online. Em um estudo de comércio eletrônico com 36 métricas offline, a melhor delas concordou com os resultados online sobre qual de dois modelos de ranking era melhor, sob uma métrica de negócio, em até 97% das vezes (Wang et al., 2023). Outra equipe de comércio eletrônico constatou que métricas de ranking offline "podem apresentar inconsistência significativa com o desempenho online, e podem até ser enganosas" (Huzhang et al., 2020). Ambos são estudos do setor sobre o próprio tráfego, que ninguém de fora consegue reproduzir. Quando dois sistemas têm desempenho aproximadamente igual, métricas diferentes frequentemente discordam entre si (Hofmann et al., 2016).

As discordâncias têm causas que você pode verificar. Os julgamentos podem deixar de fora produtos que o vencedor online exibe, o que a verificação de sensibilidade procura. A mudança pode atuar fora do ranking, na velocidade ou no layout. Ou a métrica online pode medir algo diferente de sucesso. Em um mecanismo de busca acadêmico, Radlinski et al. (2008) constataram que os clicks por consulta, assim como outras sete métricas absolutas de uso, não refletiam de forma confiável a qualidade da recuperação nos tamanhos de amostra que estudaram.

A loja pode simular um teste A/B com o comprador navegacional de o ensaio de interleaving: 5,000 buscas com BM25 como controle e 5,000 com recuperação semântica como tratamento, todas sobre consultas de teste. Meça os clicks por busca e a parcela de buscas com um click em um produto exato. Depois repita com o usuário "perfeito" da Tabela 2, o comprador perfeito, mapeado da mesma forma, que lê todos os dez resultados, dá click em todos os produtos exatos e nunca sai antes. Qual ranqueador você espera que ganhe mais clicks por busca, e todos os compradores concordariam?

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 Aprovado
"""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")
Saídapython 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

Os clicks por busca se invertem entre compradores? yes. O sinal depende de como os compradores se comportam, por isso, sozinho, não pode medir sucesso. O comprador navegacional obtém 1.362 clicks por busca com BM25 e 1.269 com recuperação semântica, com valor p de below 0.001, enquanto o comprador perfeito obtém 7.451 com recuperação semântica contra 6.443 do BM25. Um comprador que encontra um produto exato perto do topo clica nele e costuma sair, enquanto outro, que vê produtos parciais, clica em vários, ainda procurando.

A parcela de buscas com um click exato se inverte entre compradores? no. Ela favorece a recuperação semântica para o comprador navegacional, 0.799 contra 0.695, e para o comprador perfeito não mostra diferença clara, com valor p de 0.646, porque esse comprador dá click em um produto exato em 0.898 das buscas do BM25 e em 0.895 das buscas da recuperação semântica, sempre que o top 10 contém um.

Uma única resposta para todos os compradores faria dos clicks uma medida de qualidade. Eles medem comportamento, e o comportamento varia.

Regra prática: Quando os resultados offline e online discordam, encontre a causa antes de confiar em qualquer um dos dois. Verifique se a métrica online mede sucesso, como uma compra, e não atividade. Verifique o judged@10 nos resultados do vencedor online e avalie o que está faltando. Em seguida, decida o resultado online pela métrica que você escolheu antecipadamente, e acrescente consultas ou julgamentos ao conjunto de regressão para que ele faça previsões melhores da próxima vez.

Decidir se lança a mudança

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

Uma decisão de lançar combina as verificações offline e online. Escreva a lista de verificação antes de ver qualquer resultado, para que nenhum número isolado convença você a fazer uma mudança. Recomendamos estes itens, cada um com a seção que o mostra:

  1. Um ganho offline estabelecido no conjunto de regressão, pela regra de comparação planejada, com seu teste t e intervalo (diferença por consulta), contra o sistema mais forte que você tem. Armstrong et al. constataram que, ao longo de uma década de ganhos publicados em coleções TREC, "As linhas de base em geral são fracas, frequentemente abaixo da mediana dos sistemas TREC originais" (Armstrong et al., 2009).
  2. Perdas lidas, e URisk com α = 1 não negativo (URisk).
  3. Julgamentos que cobrem as duas execuções: um líder que se mantém quando os produtos não julgados de qualquer uma das execuções são contados como exatos, ou novos julgamentos quando não se mantém (produtos não julgados).
  4. Notas humanas para os escores principais de rankers baseados em LLM (capítulo 4).
  5. Latência e custo dentro do orçamento (capítulo 9).
  6. Toda configuração escolhida nas consultas de treino, com cada acesso às consultas de teste registrado (consultas reservadas).
  7. Um plano online escrito antecipadamente: a métrica primária e as salvaguardas, o tamanho obtido de um cálculo de poder, um teste A/A, uma verificação da razão de amostras e nenhuma espiada nos resultados (teste A/B). O interleaving pode filtrar os candidatos antes (team draft).

Aplique os três primeiros itens à troca da loja por recuperação semântica. O item 1 pede um ganho estabelecido, e o teste de permutação responde yes, com uma mudança média de 0.105 e um intervalo de 95% de 0.055 to 0.185. O item 2, URisk com α = 1, é 0.092.

Item 3, julgamentos que cobrem as duas execuções: se os produtos não julgados do BM25 fossem todos exatos, o BM25 marcaria 0.788 e a recuperação semântica 0.829. O líder muda? no. Os itens online aguardam o tráfego.

Regra prática: Lance quando todos os itens offline passarem e o teste online, dimensionado antecipadamente, mostrar um ganho significativo na métrica primária, sem nenhuma salvaguarda pior. Quando um item offline falhar, corrija-o antes de ir para o online, porque testes online consomem o tempo dos compradores. Quando o teste online for inconclusivo no tamanho planejado, mantenha a linha de base.

O que dá errado em produção

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

Uma loja testa mudança após mudança com tráfego real, com compradores reais no lugar dos simulados e o mesmo conjunto de regressão em cada etapa.

O painel convida a espiar. Uma plataforma de experimentos mostra resultados todos os dias, e uma equipe que para na primeira vez em que um resultado parece significativo obtém muito mais que 5% de falsos positivos, como mostra a simulação A/A. Fixe o tamanho com antecedência, ou use um método sequencial.

Os grupos não batem com o planejado. Fabijan et al. reuniram em uma taxonomia as causas de descasamento na razão de amostra (sample ratio mismatch) observadas em várias empresas. Verifique a divisão antes de ler qualquer resultado, e não confie no resultado até saber por que a divisão está fora do esperado.

O conjunto de regressão se desgasta. Toda decisão tomada olhando as consultas de teste consome parte da independência delas (Dwork et al., 2015). Registre cada análise e renove o conjunto de teste com novas consultas e novos julgamentos quando o registro ficar longo.

Um juiz LLM vira o portão. Julgamentos por LLM são baratos o bastante para avaliar todo candidato. Otero et al. descobriram que testes de significância sobre julgamentos de LLM mostraram "uma taxa excepcionalmente alta de falsos positivos quanto a diferenças estatísticas" (Otero et al., 2025). Antes de lançar um ganho medido por LLM, confirme-o em julgamentos humanos (capítulo 4).

Empates movem resultados. Produtos com pontuações iguais voltam em qualquer ordem em que a seleção de uma biblioteca os deixe (capítulo 3), então uma mudança que não toca em nenhuma pontuação ainda pode mover um resultado. Os empates invertidos do BM25 mudam o veredito de interleaving de 100 buscas da loja? yes. Quebre empates por um ID em todo ranqueador, e rode novamente um resultado próximo do limiar com os empates invertidos antes de agir sobre ele.

O interleaving não enxerga a página inteira. Acreditamos que um ranqueador mais lento, ou que muda quantos resultados aparecem, pode vencer um teste com interleaving e ainda assim perder compradores. Execute um teste A/B para mudanças como estas.

Regra prática: Automatize o teste A/A, a verificação da razão de amostra e o tamanho fixo do teste na plataforma de experimentos, mantenha um registro de cada análise das consultas de teste, quebre empates por um ID e confirme em julgamentos humanos os ganhos medidos por LLM.

Decisões tomadas neste capítulo

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

O motivo de cada padrão está na seção para a qual cada item aponta.

  • O conjunto de regressão são as 30 consultas de teste com seus julgamentos, e cada escolha usa as 50 consultas de treino (consultas reservadas).
  • Uma comparação planejada nas consultas de teste: recuperação semântica contra BM25, estabelecida somente por um valor-p de permutação abaixo de 0.05, com o teste t e um intervalo de 95% ao lado (diferença por consulta). O ranqueador de 128 dimensões é exploratório, escolhido pelo seu comportamento no conjunto de teste (URisk).
  • Cada candidato recebe uma diferença por consulta, e suas perdas são lidas à mão.
  • URisk usa α = 1, de modo que cada perda conta em dobro. É um juízo sobre quanto custa uma regressão, e uma loja com falhas caras deve aumentá-lo (URisk).
  • Quando o líder muda entre os dois cenários sem julgamento, julgue antes de comparar, e mantenha os novos julgamentos no conjunto de regressão (produtos sem julgamento).
  • As consultas de teste são observadas uma vez por decisão, e cada observação é registrada (consultas reservadas).
  • Testes A/B são dimensionados com 16σ²/Δ² antes de começar, lidos uma vez nesse tamanho, e precedidos por um teste A/A e uma verificação da razão de amostras (poder).
  • A intercalação (interleaving) usa team draft e um teste de sinal (team draft).
  • Compradores simulados seguem um modelo de cascata navegacional mapeado em três graus, com frequência uniforme de consultas, probabilidades declaradas como premissas em lib.experiments e uma semente fixa para cada simulação. Seus veredictos ensaiam um método e nunca contam como evidência (ensaio).
  • Cliques por busca não é uma métrica de sucesso por si só. Use uma medida de sucesso, como uma compra (offline e online).
  • O que o capítulo mostrou: Decida o que o faria mudar de ideia antes de olhar, depois olhe uma vez.

Este capítulo, nesta edição

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

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

Citar esta seção

Formato

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

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

Nesta página

Capítulo 11 de 11: Testando mudanças

  1. Compare duas execuções consulta por consulta
  2. Dê mais peso às perdas do que aos ganhos com o URisk
  3. Julgue os produtos que um novo ranqueador retorna
  4. Mantenha as consultas de teste fora de toda escolha
  5. Execute um teste A/B
  6. Dimensione o teste com poder estatístico
  7. Intercale dois rankings com team draft
  8. Ensaie o interleaving com compradores simulados
  9. Descubra a causa quando o offline e o online discordam
  10. Decidir se lança a mudança
  11. O que dá errado em produção
  12. Decisões tomadas neste capítulo

Voltar ao topoTodos os capítulos