Testando mudanças
Cerca de 43 minutos min de leitura, com 11 exemplos em 12 seções.
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
Nesta página
- Compare duas execuções consulta por consulta
- Dê mais peso às perdas do que aos ganhos com o URisk
- Julgue os produtos que um novo ranqueador retorna
- Mantenha as consultas de teste fora de toda escolha
- Execute um teste A/B
- Dimensione o teste com poder estatístico
- Intercale dois rankings com team draft
- Ensaie o interleaving com compradores simulados
- Descubra a causa quando o offline e o online discordam
- Decidir se lança a mudança
- O que dá errado em produção
- Decisões tomadas neste capítulo
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
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).
1"""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'."""2import pandas as pd34from lib.lexical import LexicalSearch5from lib.metrics import evaluate6from lib.semantic import SemanticSearch7from lib.significance import compare8from lib.store import load_products, load_queries, qrels910PLANNED_COMPARISONS = 1 # this chapter's tests on the test queries11threshold = 0.05 / PLANNED_COMPARISONS # Bonferroni: one comparison keeps 0.051213products, queries, judgments = load_products(), load_queries("test"), qrels("test")14baseline = evaluate(LexicalSearch(products).run(queries, k=100), judgments) # what the store runs15candidate = evaluate(SemanticSearch().run(queries, k=100), judgments) # the change1617diff = pd.DataFrame({"query": queries["query"], "bm25": baseline["ndcg@10"], "semantic": candidate["ndcg@10"]})18# rounded to 3 decimals, as lib.significance rounds before it counts wins, losses and ties19diff["change"] = (diff["semantic"] - diff["bm25"]).round(3) # one row per test query2021print(f"bm25 ndcg@10: {diff['bm25'].mean():.3f}")22print(f"semantic ndcg@10: {diff['semantic'].mean():.3f}")23result = compare(candidate["ndcg@10"], baseline["ndcg@10"], confidence=1 - threshold) # chapter 3's comparison24print(f"mean change: {result['mean difference']:.3f}")25print(f"threshold: {threshold:g}")26print(f"permutation test p: {result['permutation p']:.3f}")27print(f"paired t-test p: {result['t-test p']:.3f}")28print(f"{(1 - threshold) * 100:g}% interval: {result['ci low']:.3f} to {result['ci high']:.3f}")29print("established:", "yes" if result["permutation p"] < threshold else "no")30print("wins:", (diff["change"] > 0).sum())31print("losses:", (diff["change"] < 0).sum())32print("ties:", (diff["change"] == 0).sum())33print(f"largest loss: {diff['change'].min():.3f}")34print()35print(diff[diff["change"] < 0].sort_values("change").round(3).to_string())
python diff-semantic-against-bm25.pybm25 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
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:
1"""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."""2from lib.lexical import LexicalSearch3from lib.metrics import evaluate4from lib.semantic import SemanticSearch5from lib.significance import compare6from lib.store import load_products, load_queries, qrels78ALPHA = 1 # each loss counts alpha + 1 times: here, double91011def urisk(change, alpha):12 """Mean change per query, with every loss counted alpha + 1 times (TREC 2013 Web track)."""13 # gains are the positive changes; losses are the negative ones, made positive14 wins, losses = change.clip(lower=0).sum(), -change.clip(upper=0).sum()15 return (wins - (alpha + 1) * losses) / len(change)161718products, queries, judgments = load_products(), load_queries("test"), qrels("test")19baseline = evaluate(LexicalSearch(products).run(queries, k=100), judgments)20candidates = {"semantic": SemanticSearch(), "semantic 128": SemanticSearch(dims=128)} # all 768 numbers, or the first 1282122print(f"bm25 judged@10: {baseline['judged@10'].mean():.3f}")23evaluated = {name: evaluate(search.run(queries, k=100), judgments) for name, search in candidates.items()}24for name, scores in evaluated.items():25 # rounded to 3 decimals, so the wins and losses count the printed changes26 change = (scores["ndcg@10"] - baseline["ndcg@10"]).round(3)27 print(f"{name} judged@10: {scores['judged@10'].mean():.3f}")28 print(f"{name} mean change: {change.mean():.3f}")29 print(f"{name} wins: {(change > 0).sum()}")30 print(f"{name} losses: {(change < 0).sum()}")31 print(f"{name} largest loss: {change.min():.3f}")32 print(f"{name} urisk with alpha {ALPHA}: {urisk(change, ALPHA):.3f}")3334# a demonstration, chosen for how it behaves on test: its tests describe it, and it is never established35result = compare(evaluated["semantic 128"]["ndcg@10"], baseline["ndcg@10"], confidence=0.95)36print(f"semantic 128 permutation test p: {result['permutation p']:.3f}")37print(f"semantic 128 paired t-test p: {result['t-test p']:.3f}")38print(f"semantic 128 interval: {result['ci low']:.3f} to {result['ci high']:.3f}")
python urisk-of-two-candidates.pybm25 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
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:
1"""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."""2import numpy as np34from lib.lexical import LexicalSearch5from lib.metrics import ndcg_at_k6from lib.semantic import SemanticSearch7from lib.store import load_products, load_queries, qrels89products, queries, judgments = load_products(), load_queries("test"), qrels("test")10runs = {"bm25": LexicalSearch(products).run(queries, k=100),11 "semantic 128": SemanticSearch(dims=128).run(queries, k=100),12 "semantic": SemanticSearch().run(queries, k=100)}131415def unjudged(run):16 """(query_id, product_id) pairs in a run's top 10 that nobody judged."""17 return {(query_id, product_id) for query_id in judgments for product_id in run[query_id][:10]18 if product_id not in judgments[query_id]}192021def score(run, exact=()):22 """Mean nDCG@10 with the given unjudged pairs judged exact, for every run alike: the ideal moves too."""23 # a copy of the judgments, so each scenario changes only its own exact pairs24 scenario = {query_id: dict(grades) for query_id, grades in judgments.items()}25 # grade 2 is exact, the top grade26 for query_id, product_id in exact:27 scenario[query_id][product_id] = 228 return np.mean([ndcg_at_k(run[query_id], scenario[query_id], 10) for query_id in scenario])293031for name in ["bm25", "semantic 128"]:32 print(f"unjudged pairs in the top 10, {name}: {len(unjudged(runs[name]))}")33# the empty set is the judgments as they are34scenarios = {"as judged": set(), **{f"{name}'s unjudged exact": unjudged(runs[name]) for name in runs}}35scores = {(scenario, name): score(run, exact) for scenario, exact in scenarios.items() for name, run in runs.items()}36for scenario, name in [("as judged", "bm25"), ("as judged", "semantic 128"), ("bm25's unjudged exact", "bm25"),37 ("bm25's unjudged exact", "semantic 128"), ("bm25's unjudged exact", "semantic"),38 ("semantic 128's unjudged exact", "bm25"), ("semantic 128's unjudged exact", "semantic 128")]:39 print(f"{scenario}, {name}: {scores[scenario, name]:.3f}")40for candidate in ["semantic 128", "semantic"]:41 # a set holding both True and False means the leader changes between scenarios42 leaders = {scores[s, candidate] > scores[s, "bm25"] for s in scenarios}43 print(f"leader changes, {candidate} against bm25:", "yes" if len(leaders) > 1 else "no")44# | is the union: pairs either run shows, each counted once45print("pairs to judge, semantic 128 against bm25:", len(unjudged(runs["bm25"]) | unjudged(runs["semantic 128"])))
python unjudged-score-range.pyunjudged 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
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.
1"""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."""2import numpy as np34from lib.blend import best_alpha, scores_by_alpha, weighted_rrf5from lib.lexical import LexicalSearch6from lib.semantic import SemanticSearch7from lib.store import load_products, load_queries, qrels89queries, judgments = load_queries(), qrels() # all 80 queries, train and test10bm25 = LexicalSearch(load_products()).run(queries, k=100)11semantic = SemanticSearch().run(queries, k=100)12per_query = scores_by_alpha(lambda weight: weighted_rrf(bm25, semantic, weight), judgments) # nDCG@10, a column per weight13train = per_query.loc[load_queries("train").index]14test = per_query.loc[load_queries("test").index]1516# best_alpha breaks ties toward the smaller weight17chosen_on_train, chosen_on_test = best_alpha(train), best_alpha(test)18print("settings tried:", per_query.shape[1])19print(f"semantic alone, test ndcg@10: {test[1.0].mean():.3f}")20print("semantic weight chosen on train:", chosen_on_train)21print(f"test ndcg@10, weight chosen on train: {test[chosen_on_train].mean():.3f}")22print("semantic weight chosen on test:", chosen_on_test)23print(f"test ndcg@10, weight chosen on test: {test[chosen_on_test].mean():.3f}")2425# How much does choosing on the queries you report inflate the score? Split the train queries26# at random, 30 to choose on and 20 to report on, and compare the two ways of choosing.27# a fixed seed, so the random splits are the same on every run28rng = np.random.default_rng(2026)29scores = train.to_numpy()30inflation = []31for _ in range(1000):32 order = rng.permutation(len(scores))33 # the first 30 of the shuffled queries choose the weight; the other 20 report it34 choose, report = scores[order[:30]].mean(axis=0), scores[order[30:]].mean(axis=0)35 # argmax takes the first of equal means, the smaller weight, as best_alpha does36 inflation.append(report.max() - report[choose.argmax()])37print(f"average inflation, 20 reported queries: {np.mean(inflation):.3f}")
python tuning-on-test-inflates.pysettings 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
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.
1"""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."""2import numpy as np3from scipy import stats45# Assumptions for the simulation, not the store's data: 2,000 shoppers a day in each group,6# 5% of them buy, and the test is planned to run 14 days. Both groups get the same search (an A/A test).7TESTS, DAYS, SHOPPERS_PER_DAY, CONVERSION = 2000, 14, 2000, 0.0589# a fixed seed, so the simulated tests are the same on every run10rng = np.random.default_rng(2026)11buyers = rng.binomial(SHOPPERS_PER_DAY, CONVERSION, size=(TESTS, DAYS, 2)).cumsum(axis=1) # running totals12shoppers = SHOPPERS_PER_DAY * np.arange(1, DAYS + 1)[None, :] # per group, by day13rate_a, rate_b = buyers[..., 0] / shoppers, buyers[..., 1] / shoppers14pooled = (rate_a + rate_b) / 215# two-proportion z for each day, using the pooled rate of the two groups16z = (rate_b - rate_a) / np.sqrt(pooled * (1 - pooled) * 2 / shoppers)17# two-sided: a gap in either direction counts18p_value = 2 * stats.norm.sf(np.abs(z))1920print(f"simulated A/A tests: {TESTS:,}")21# the last day is the planned end, day 1422print(f"significant at the planned end: {(p_value[:, -1] < 0.05).mean():.3f}")23print(f"significant on some day, checked daily: {(p_value < 0.05).any(axis=1).mean():.3f}")2425# A sample ratio mismatch: the split was planned 50/50, but the groups came out unequal.26control, treatment = 28_000, 27_10027# the default expected share is one half, as in a 50/50 split28p = stats.binomtest(treatment, control + treatment).pvalue29print(f"sample ratio mismatch p: {p:.3f}" if p >= 0.001 else "sample ratio mismatch p: below 0.001")
python aa-tests-with-peeking.pysimulated 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
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%.
1"""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."""2from scipy import stats34SIGNIFICANCE, POWER = 0.05, 0.805z = stats.norm.ppf(1 - SIGNIFICANCE / 2) + stats.norm.ppf(POWER) # 1.96 + 0.846print(f"coefficient for two groups: {2 * z ** 2:.1f}") # rounds to the 16 of the rule of thumb789def users_per_group(variance, change):10 """Kohavi et al.'s rule of thumb: about 16 * variance / change**2 users in each group."""11 return 16 * variance / change ** 2121314# Their worked examples: revenue per user (mean $3.75, standard deviation $30), and a 5% conversion rate,15# each with a 5% relative change to detect.16print(f"users per group, revenue: {users_per_group(30 ** 2, 0.05 * 3.75):,.0f}")17# a conversion rate's variance is p times (1 - p), here with p = 5%; the change is 5% of that rate18print(f"users per group, conversion: {users_per_group(0.05 * 0.95, 0.05 * 0.05):,.0f}")1920# The store, assuming a 5% conversion rate like theirs: smaller changes need far more users.21for relative in [0.02, 0.01]:22 # the change in conversion, as an absolute rate: a relative change of this size in the 5% rate23 print(f"users per group for a {relative:.0%} change: {users_per_group(0.05 * 0.95, 0.05 * relative):,.0f}")
python sample-size-from-power.pycoefficient 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.
1"""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."""2import numpy as np3from scipy import stats45from lib.fusion import reciprocal_rank_fusion6from lib.lexical import LexicalSearch7from lib.metrics import evaluate8from lib.semantic import SemanticSearch9from lib.store import load_products, load_queries, qrels1011SIGNIFICANCE, POWER = 0.05, 0.8012queries, judgments = load_queries("test"), qrels("test")13bm25 = LexicalSearch(load_products()).run(queries, k=100)14semantic = SemanticSearch().run(queries, k=100)15hybrid = reciprocal_rank_fusion([bm25, semantic])16change = evaluate(hybrid, judgments)["ndcg@10"] - evaluate(semantic, judgments)["ndcg@10"]17spread = change.std() # of the per-query differences1819z = stats.norm.ppf(1 - SIGNIFICANCE / 2) + stats.norm.ppf(POWER)20print(f"spread of per-query changes: {spread:.3f}")21print(f"coefficient for paired queries: {z ** 2:.1f}") # one sample of differences, so half of 1622# z standard errors of the mean change: the smallest change the test can detect23detectable = z * spread / np.sqrt(len(change))24print(f"smallest change 30 queries detect: {detectable:.3f}")25# n = z squared times spread squared, over the change squared, solved for n26print(f"queries needed for a change of 0.01: {z ** 2 * spread ** 2 / 0.01 ** 2:.0f}")2728# Check the arithmetic by simulation: draw 30 normally distributed changes with that mean and spread,29# 10,000 times, and test each. The real differences aren't normal, so this checks the formula, not the data.30rng = np.random.default_rng(2026)31# ttest_1samp tests each draw against popmean 0, the no-change null32power = stats.power(stats.ttest_1samp, lambda size: rng.normal(detectable, spread, size=size), (len(change),),33 significance=SIGNIFICANCE, kwargs={"popmean": 0})34# .item() takes the single value out of the result, which holds one simulated power35print(f"simulated power at that change: {power.power.item():.3f}")36print("simulated power below the planned 0.8:", "yes" if power.power.item() < POWER else "no")
python queries-needed-for-power.pyspread 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
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:
1"""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."""2import numpy as np34from lib import experiments5from lib.lexical import LexicalSearch6from lib.semantic import SemanticSearch7from lib.store import load_products, load_queries, qrels89LABELS = {2: "exact", 1: "partial", 0: "irrelevant"}101112def team_draft(ranking_a, ranking_b, rng, length=10):13 """Like picking teams: the team with fewer picks goes next, a coin flip decides when they're level,14 and each team adds its best product that isn't shown yet."""15 shown, teams = [], []16 while len(shown) < length:17 picks_a, picks_b = teams.count("a"), teams.count("b")18 # the coin is drawn only when the teams are level19 a_picks = picks_a < picks_b or (picks_a == picks_b and rng.random() < 0.5)20 ranking, team = (ranking_a, "a") if a_picks else (ranking_b, "b")21 # the team's best product that isn't shown yet, from its own ranking22 shown.append(next(p for p in ranking if p not in shown))23 teams.append(team)24 return shown, teams252627products, queries, judgments = load_products(), load_queries("test"), qrels("test")[246] # clear shower curtain28semantic = list(SemanticSearch().search(246, k=100).index)29bm25 = list(LexicalSearch(products).search(queries.at[246, "query"], k=100).index)3031shown, teams = team_draft(semantic, bm25, np.random.default_rng(7))32# judgments.get returns None for a product nobody judged, and LABELS.get then gives 'unjudged'33# names are cut at 45 characters to keep the columns aligned34for position, (product_id, team) in enumerate(zip(shown, teams), start=1):35 name = {"a": "semantic", "b": "bm25"}[team]36 print(f"{position:>2} {name:<8} {LABELS.get(judgments.get(product_id), 'unjudged'):<10} {products.at[product_id, 'name'][:45]}")37# lib.experiments holds the same function, which the simulations use38print("same list from lib.experiments:", "yes" if experiments.team_draft(semantic, bm25, np.random.default_rng(7)) == (shown, teams) else "no")
python 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
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:
1"""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."""2import numpy as np34from lib.experiments import NAVIGATIONAL, cascade_clicks, team_draft5from lib.lexical import LexicalSearch6from lib.semantic import SemanticSearch7from lib.store import load_products, load_queries, qrels89LABELS = {2: "exact", 1: "partial", 0: "irrelevant"}10products, queries, judgments = load_products(), load_queries("test"), qrels("test")[246] # clear shower curtain11semantic = list(SemanticSearch().search(246, k=100).index)12bm25 = list(LexicalSearch(products).search(queries.at[246, "query"], k=100).index)13shown, teams = team_draft(semantic, bm25, np.random.default_rng(7)) # the team-draft example's list14team_names = {"a": "semantic", "b": "bm25"}1516# the same seed as the check at the end, so both draw the same clicks17rng = np.random.default_rng(2026)18clicks = []19for position, product_id in enumerate(shown):20 grade = judgments.get(product_id, 0) # unjudged counts as 021 # click and stop probabilities for the grade: 0 irrelevant, 1 partial, 2 exact22 clicked = rng.random() < NAVIGATIONAL["click"][grade]23 # the second draw happens only after a click, the order cascade_clicks uses24 leaves = clicked and rng.random() < NAVIGATIONAL["stop"][grade] # only a click can end the visit25 label = LABELS.get(judgments.get(product_id), "unjudged")26 print(f"{position + 1:>2} {team_names[teams[position]]:<8} {label:<10} {'clicks' if clicked else '':<6} {'leaves' if leaves else ''}")27 if clicked:28 clicks.append(position)29 if leaves:30 break3132credited = [team_names[teams[position]] for position in clicks] # each click counts for the team that picked it33for_semantic, for_bm25 = credited.count("semantic"), credited.count("bm25")34print("clicks for semantic:", for_semantic)35print("clicks for bm25:", for_bm25)36print("this search goes to:", "semantic" if for_semantic > for_bm25 else "bm25" if for_bm25 > for_semantic else "neither, a tie")37print("same clicks from lib.experiments:", "yes" if cascade_clicks(shown, judgments, np.random.default_rng(2026)) == clicks else "no")
python 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:
1"""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."""2import numpy as np3from scipy import stats45from lib.experiments import NAVIGATIONAL, simulate_interleaving6from lib.fusion import reciprocal_rank_fusion7from lib.lexical import LexicalSearch8from lib.semantic import SemanticSearch9from lib.store import load_products, load_queries, qrels1011for grade, label in [(2, "exact"), (1, "partial"), (0, "irrelevant")]: # the assumptions, from lib.experiments12 print(f"{label} click probability: {NAVIGATIONAL['click'][grade]}")13 print(f"{label} stop probability: {NAVIGATIONAL['stop'][grade]}")1415# lexsort's last key sorts first: the score, highest first, then the product_id, highest first among ties16def ties_reversed(scores): # BM25's ranking, with equal scores in descending product_id order instead17 return scores.index[np.lexsort((-scores.index.to_numpy(), -scores.to_numpy()))].tolist()181920queries, judgments = load_queries("test"), qrels("test")21lexical = LexicalSearch(load_products())22bm25 = lexical.run(queries, k=100) # equal scores by product_id23semantic = SemanticSearch().run(queries, k=100)24hybrid = reciprocal_rank_fusion([bm25, semantic])25bm25_reversed = {q: ties_reversed(lexical.search(query, k=100)) for q, query in queries["query"].items()}2627pairs = {"semantic against bm25": (semantic, bm25), "hybrid against semantic": (hybrid, semantic),28 "hybrid with bm25 ties reversed against semantic": (reciprocal_rank_fusion([bm25_reversed, semantic]), semantic)}29below = {}30for name, (run_a, run_b) in pairs.items():31 # a fresh seed for each pair, so every pair sees the same 10,000 queries32 outcomes = simulate_interleaving(run_a, run_b, judgments, 10_000, np.random.default_rng(2026))33 for searches in [100, 1_000, 10_000]:34 # the first 100, 1,000 or 10,000 of the same searches, so the three verdicts share data35 wins, losses = (outcomes[:searches] == 1).sum(), (outcomes[:searches] == -1).sum()36 p = stats.binomtest(wins, wins + losses).pvalue # sign test; ties left out37 below[name, searches] = p < 0.0538 shown = f"{p:.3f}" if p >= 0.001 else "below 0.001"39 print(f"{name}, {searches:,} searches: {wins} wins, {losses} losses, p {shown}")40changes = below["hybrid against semantic", 100] != below["hybrid with bm25 ties reversed against semantic", 100]41print("hybrid against semantic, verdict at 100 searches changes with bm25 ties reversed:", "yes" if changes else "no")
python simulated-interleaving-verdict.pyexact 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
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?
1"""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."""2import numpy as np3from scipy import stats45from lib.experiments import SHOPPERS, simulate_searches6from lib.lexical import LexicalSearch7from lib.semantic import SemanticSearch8from lib.store import load_products, load_queries, qrels910queries, judgments = load_queries("test"), qrels("test")11arms = {"bm25": LexicalSearch(load_products()).run(queries, k=100), # control12 "semantic": SemanticSearch().run(queries, k=100)} # treatment13metrics = {"clicks per search": "clicks", "share of searches with an exact click": "exact_click"}1415significant_leaders = {label: set() for label in metrics} # rankers ahead at p below 0.0516for shopper_name, shopper in SHOPPERS.items(): # navigational, then perfect17 # one seed per shopper: the two rankers draw from it in turn, bm25 first18 rng = np.random.default_rng(2026)19 searches = {name: simulate_searches(run, judgments, 5_000, rng, shopper) for name, run in arms.items()}20 for label, column in metrics.items():21 means = {name: table[column].mean() for name, table in searches.items()}22 for name, mean in means.items():23 print(f"{shopper_name} shopper, {name} {label}: {mean:.3f}")24 # exact_click holds True and False; as floats they are 1 and 0 for the t-test25 p = stats.ttest_ind(searches["semantic"][column].astype(float), searches["bm25"][column].astype(float)).pvalue26 print(f"{shopper_name} shopper, {label} p: " + (f"{p:.3f}" if p >= 0.001 else "below 0.001"))27 if p < 0.05:28 significant_leaders[label].add(max(means, key=means.get))29for label in metrics:30 print(f"{label} reverses between shoppers:", "yes" if len(significant_leaders[label]) > 1 else "no")
python clicks-per-search-misleads.pynavigational 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
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:
- 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).
- Perdas lidas, e URisk com α = 1 não negativo (URisk).
- 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).
- Notas humanas para os escores principais de rankers baseados em LLM (capítulo 4).
- Latência e custo dentro do orçamento (capítulo 9).
- Toda configuração escolhida nas consultas de treino, com cada acesso às consultas de teste registrado (consultas reservadas).
- 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
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
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.experimentse 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.