Medindo a busca
Cerca de 44 minutos min de leitura, com 12 exemplos em 13 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
- Conte os produtos relevantes nos top k
- Pontue o primeiro resultado relevante com a posição recíproca
- Construa o nDCG a partir de ganhos descontados
- Confira
ndcg_scorecom o scikit-learn - Escolha uma métrica antes de comparar
- Leia as diferenças por consulta, não só a média
- Teste uma diferença com um teste de permutação
- Obtenha o valor p a partir de um teste t pareado
- Informe o tamanho da diferença
- Decida com antecedência o que conta como estabelecido
- Comparar execuções em um harness de avaliação
- O que dá errado em produção
- Decisões tomadas neste capítulo
Ao final deste capítulo, você será capaz de calcular do zero as métricas padrão de ranqueamento, verificá-las com o scikit-learn, escolher uma delas antes de comparar rankers, e dizer se a diferença entre dois rankers nas suas consultas de teste está estabelecida ou pode ser fruto do acaso.
O Capítulo 1 terminou com uma ordenação, tendo a recuperação semântica como o ranker a ser superado. Nas consultas de teste da loja, buscas com as quais nenhum ranker foi ajustado, o BM25 obtém um nDCG@10 de 0.725, a recuperação semântica 0.830, o híbrido 0.812 e o híbrido com reranqueamento 0.798. Duas perguntas precisam ser respondidas antes que essa ordenação possa ser considerada confiável. As métricas medem o que importa para um comprador, e são calculadas corretamente? E as diferenças são reais, ou o acaso poderia produzi-las em 30 consultas? Este capítulo responde às duas, e termina com a regra do livro para uma diferença estabelecida e com um arcabouço de avaliação que a aplica.
Conte os produtos relevantes nos top k
A maioria das métricas de ranqueamento parte de uma pergunta: quantos dos resultados que o cliente vê são relevantes? A precisão em k, escrita precision@k, é a proporção dos k primeiros resultados que são relevantes. A revocação em k, recall@k, é a proporção de todos os produtos relevantes que aparecem nos k primeiros. Manning e colegas descrevem a precisão como a proporção dos documentos recuperados que são relevantes e a revocação como a proporção dos documentos relevantes que são recuperados, e observam que aumentar uma costuma custar a outra (Manning et al., 2008, seção 8.3). As duas exigem uma noção binária de relevância: sim ou não. Neste livro, um produto é relevante para uma consulta quando seu julgamento é exato, nota 2. Um produto que ninguém julgou para a consulta conta como não relevante.
Os 10 primeiros resultados do BM25 para a consulta de teste da loja clear shower curtain misturam cortinas transparentes, cortinas que não são transparentes e ganchos para cortina de box. Quantos desses dez são exatos, e qual é a pontuação máxima que qualquer consulta de teste poderia obter? O exemplo responde às duas perguntas à mão e confere a contagem com lib.metrics:
1"""Counts the exact products in BM25's top 10 for one query, computes precision and recall by hand, and checks them against lib.metrics, then finds the best score each test query could reach. The prose's point rests on the "exact in the top 10" and "exact products judged" lines, and on the ceiling lines after the blank line."""2import pandas as pd34from lib.lexical import LexicalSearch5from lib.metrics import precision_at_k, recall_at_k6from lib.store import load_products, load_queries, qrels78queries, judgments = load_queries("test"), qrels("test")9ranking = list(LexicalSearch(load_products()).search(queries.at[246, "query"], k=10).index) # clear shower curtain10# grade 2 is exact; a product the judges never graded is absent from this dict, so it is not exact11exact = {product_id for product_id, grade in judgments[246].items() if grade == 2}1213found = sum(product_id in exact for product_id in ranking[:10])14print("exact in the top 10:", found)15print("exact products judged:", len(exact))16print(f"precision@10 by hand: {found / 10:.3f}")17print(f"recall@10 by hand: {found / len(exact):.3f}")18print(f"precision@10 from lib.metrics: {precision_at_k(ranking, judgments[246], 10):.3f}")19print(f"recall@10 from lib.metrics: {recall_at_k(ranking, judgments[246], 10):.3f}")2021# the best any ranking can do: a top 10 that holds as many exact products as the query has22exact_counts = pd.Series({query_id: sum(grade == 2 for grade in per_query.values())23 for query_id, per_query in judgments.items()})24# a top 10 can hold at most 10 exact products, and no more than the query has25best_precision = exact_counts.clip(upper=10) / 1026# only 10 results are shown, so at most 10 of a query's exact products can be retrieved27best_recall = exact_counts.clip(upper=10) / exact_counts28print()29print("queries where precision@10 can't reach 1:", (best_precision < 1).sum())30print("fewest exact products for a query:", exact_counts.min())31print("queries with that few:", (exact_counts == exact_counts.min()).sum())32print(f"best precision@10 for those queries: {best_precision.min():.3f}")33print("queries where recall@10 can't reach 1:", (best_recall < 1).sum())34most = exact_counts.idxmax()35print("query with the most exact products:", queries.at[most, "query"])36print("its exact products:", exact_counts[most])37print(f"its best recall@10: {best_recall[most]:.3f}")
python precision-recall-by-hand.pyexact in the top 10: 4
exact products judged: 12
precision@10 by hand: 0.400
recall@10 by hand: 0.333
precision@10 from lib.metrics: 0.400
recall@10 from lib.metrics: 0.333
queries where precision@10 can't reach 1: 7
fewest exact products for a query: 4
queries with that few: 4
best precision@10 for those queries: 0.400
queries where recall@10 can't reach 1: 22
query with the most exact products: outdoor light fixtures
its exact products: 170
its best recall@10: 0.059
lib.metrics concorda com a contagem feita à mão. Dos 10 primeiros, 4 são exatos, então a precisão@10 é 0.400. Em relação aos 12 produtos exatos marcados pelos avaliadores para esta consulta, a revocação@10 é 0.333. precision_at_k e recall_at_k dão os mesmos dois valores.
Nenhuma das duas métricas tem um teto único para todas as consultas. Uma consulta com menos de 10 produtos exatos não consegue preencher os 10 primeiros só com eles, então a precisão@10 não pode chegar a 1. 7 consultas de teste são assim, e as 4 consultas com apenas 4 produtos exatos podem alcançar, no máximo, uma precisão@10 de 0.400.
Uma consulta com mais de 10 produtos exatos não consegue alcançar revocação total em 10 resultados. Isso vale para 22 das consultas de teste. A consulta com o maior número, outdoor light fixtures, tem 170 produtos exatos, então sua revocação@10 chega, no máximo, a 0.059. Uma média sobre as consultas de teste mistura consultas que podem obter 1 com consultas que não podem.
A revocação tem um segundo problema, porque seu denominador conta apenas os produtos exatos que os avaliadores encontraram. O WANDS julgou candidatos reunidos para cada consulta, não o catálogo inteiro (capítulo 1), então alguns produtos exatos nunca foram julgados. Zobel constatou que julgamentos reunidos dessa forma superestimam a revocação (Saiba de onde vieram os julgamentos).
Regra prática: Use a precisão@10 quando importar quanto da primeira página está certo, e leia-a junto com o teto de cada consulta. Não transforme a revocação@10 em destaque na busca de produtos, em que uma consulta pode ter mais de cem produtos relevantes, como outdoor light fixtures tem. Recomendamos a revocação em um corte profundo, como o top 100, para uma única tarefa: verificar se a recuperação passa produtos relevantes suficientes para um reranqueador. Mesmo assim, leia-a como uma superestimativa.
Pontue o primeiro resultado relevante com a posição recíproca
A precisão conta a página inteira, mas alguns compradores querem um único produto: uma peça de reposição ou um modelo que já conhecem. Para eles, o que importa é a que distância da primeira posição está o primeiro bom resultado. A posição recíproca (RR, do inglês reciprocal rank) pontua uma consulta como 1 dividido pela posição do primeiro resultado relevante, ou 0 se não houver nenhum, e a média de RR sobre as consultas é a média da posição recíproca (MRR, do inglês mean reciprocal rank). A TREC, a Text REtrieval Conference, executa avaliações compartilhadas de sistemas de busca. A MRR foi a medida oficial de sua trilha de perguntas e respostas na TREC-8, onde cada pergunta pontuava o inverso da posição da primeira resposta correta, ou 0 quando nenhuma das cinco respostas estava correta. A trilha a escolheu em parte porque ela permanece entre 0 e 1 e se combina bem em médias (Voorhees, 1999).
Fazer a média de RR é controverso. Fuhr observa que, sob RR, "a diferença entre as posições 1 e 2 é a mesma que a diferença entre as posições 2 e ∞", por isso RR não é uma escala intervalar, uma escala na qual passos iguais significam diferenças iguais, e ele defende que sua média não deveria ser calculada (Fuhr, 2017, seção 2.1). Sakai não vê razão para proibi-la (Sakai, 2020). Moffat argumenta que essas métricas são mais significativas em sua forma atual do que nas versões intervalares propostas para elas (Moffat, 2022). Usamos a MRR com essa ressalva: ela é um resumo grosseiro.
RR depende de onde você traça a linha do que é relevante, então pontue o ranking do BM25 para clear shower curtain duas vezes: uma contando apenas produtos exatos, outra contando também os parciais. Em seguida, calcule a MRR para o BM25 e para a busca semântica sobre as consultas de teste:
1"""Writes reciprocal rank by hand for one query under two grade thresholds, then computes MRR for BM25 and semantic retrieval and checks it against lib.metrics. The prose's point rests on the two rr lines for clear shower curtain and the two MRR lines."""2import pandas as pd34from lib.lexical import LexicalSearch5from lib.metrics import evaluate6from lib.semantic import SemanticSearch7from lib.store import load_products, load_queries, qrels8910# relevant=2 counts only exact products; relevant=1 counts partial ones too11def reciprocal_rank(ranking, judgments, relevant=2):12 """1 / the position of the first relevant product, or 0 if the ranking has none."""13 # positions count from 1, as a shopper counts results14 for position, product_id in enumerate(ranking, start=1):15 # a product nobody judged has grade 0, so it never counts as relevant16 if judgments.get(product_id, 0) >= relevant:17 return 1 / position18 return 0.0192021queries, judgments = load_queries("test"), qrels("test")22# each run goes 100 products deep, so RR can look past the top 10 for the first exact product23runs = {"bm25": LexicalSearch(load_products()).run(queries, k=100), "semantic": SemanticSearch().run(queries, k=100)}2425ranking = runs["bm25"][246] # clear shower curtain26print(f"rr, exact counts as relevant: {reciprocal_rank(ranking, judgments[246]):.3f}")27print(f"rr, partial or better counts: {reciprocal_rank(ranking, judgments[246], relevant=1):.3f}")2829for name, run in runs.items():30 rr = pd.Series({query_id: reciprocal_rank(run[query_id], judgments[query_id]) for query_id in judgments})31 print(f"{name} mrr: {rr.mean():.3f}")32 print(f"{name} mrr from lib.metrics: {evaluate(run, judgments)['rr'].mean():.3f}")33 print(f"{name} queries with rr of 1:", (rr == 1).sum())
python reciprocal-rank-by-hand.pyrr, exact counts as relevant: 0.500
rr, partial or better counts: 1.000
bm25 mrr: 0.650
bm25 mrr from lib.metrics: 0.650
bm25 queries with rr of 1: 16
semantic mrr: 0.787
semantic mrr from lib.metrics: 0.787
semantic queries with rr of 1: 22
O limiar de graus altera a RR para essa única consulta. O primeiro resultado do BM25 para clear shower curtain é uma correspondência parcial e o segundo é exato, então a RR é 0.500 quando apenas produtos exatos contam, e 1.000 quando os parciais também contam. Sempre que citar a RR, diga quais graus contam. A média sobre as consultas de teste corresponde à coluna rr de lib.metrics.evaluate: o BM25 obtém 0.650 e a busca semântica 0.787. Essa coluna procura o primeiro produto exato em qualquer ponto da execução, e não apenas no top 10.
A RR tem um ponto cego. Ela vale 1 para 22 consultas de teste na busca semântica e para 16 no BM25, e nessas consultas não enxerga nada abaixo do primeiro resultado. Um ranqueador que coloca um produto exato em primeiro e nove irrelevantes depois pontua igual a um top 10 perfeito.
Regra prática: Apresente a MRR como o principal indicador somente quando os compradores precisarem de um produto certo, como um número de modelo ou um produto nomeado, por exemplo kohler whitehaven farmhouse kitchen sink. Para consultas em que os compradores navegam por uma página de opções, como wooden chair outdoor, use o nDCG@10 como principal indicador e apresente a MRR ao lado dele.
Construa o nDCG a partir de ganhos descontados
Diferentemente da precisão e do RR, o nDCG@10, que o capítulo 1 usou para pontuar um ranking, lê as notas. Cada resultado contribui com sua nota como ganho, reduzido por um desconto que cresce com sua posição, e a soma é o ganho cumulativo descontado (DCG, discounted cumulative gain). O DCG normalizado (nDCG) divide o DCG de um ranking pelo DCG do ranking ideal. Duas de suas partes têm várias versões que alteram o número. A primeira é o ranking ideal. Järvelin e Kekäläinen, que introduziram o DCG, o baseiam na "base de recall do tópico de busca, e não no resultado de alguma técnica de RI" (Järvelin e Kekäläinen, 2002). Na prática, isso significa a melhor ordem de todos os produtos avaliados para a consulta, e não apenas dos produtos que um ranqueador retornou. A segunda é o desconto: eles propuseram dividir a pontuação de um documento pelo logaritmo de sua posição, e as versões diferem quanto ao logaritmo usado e a partir de qual posição.
A fórmula em lib.metrics, em que grade(i) é a nota do produto na posição i:
DCG@k = sum over positions i from 1 to k of grade(i) / log2(i + 1)
nDCG@k = DCG@k / DCG@k of the ideal ranking
Essa não é a única versão em uso. Järvelin e Kekäläinen deixaram sem desconto as posições abaixo da base do logaritmo, de modo que, com base 2, as duas primeiras posições contam integralmente. Burges et al. usaram um ganho exponencial, 2^grade − 1, com desconto log(1 + rank) (Burges et al., 2005). As ferramentas de avaliação também diferem: a documentação do ir-measures lista opções de nDCG diferentes para pytrec_eval e para gdeval (ir-measures). Por isso, sempre que citar um nDCG, nomeie a variante.
Escreva o DCG e o nDCG do zero e confira-os com lib.metrics nas execuções BM25, semântica e híbrida do capítulo 1. Uma das pontuações parece boa demais para ser verdadeira:
1"""Writes DCG and nDCG from scratch and checks them against lib.metrics on every test query of three runs, then prints one query's grades beside its best possible grades. The prose's point rests on the largest-difference line and on the ndcg@10 line for luau string lights, read with the grade lines above it."""2import math34from lib.fusion import reciprocal_rank_fusion5from lib.lexical import LexicalSearch6from lib.metrics import ndcg_at_k7from lib.semantic import SemanticSearch8from lib.store import load_products, load_queries, qrels91011def dcg(grades, k):12 """Each grade divided by log2 of its position plus one, added up over the top k."""13 # positions count from 1, so the first result is divided by log2(2)14 return sum(grade / math.log2(position + 1) for position, grade in enumerate(grades[:k], start=1))151617def ndcg(ranking, judgments, k=10):18 """DCG of the ranking over DCG of the best order of every judged product (unjudged counts as 0)."""19 # the ideal ranking: every judged product, best grade first20 ideal = dcg(sorted(judgments.values(), reverse=True), k)21 # a product nobody judged counts as grade 0 in the ranking22 return dcg([judgments.get(product_id, 0) for product_id in ranking], k) / ideal232425queries, judgments = load_queries("test"), qrels("test")26bm25 = LexicalSearch(load_products()).run(queries, k=100)27semantic = SemanticSearch().run(queries, k=100)28runs = {"bm25": bm25, "semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}2930gaps = [abs(ndcg(run[query_id], judgments[query_id]) - ndcg_at_k(run[query_id], judgments[query_id], 10))31 for run in runs.values() for query_id in judgments]32print("rankings checked:", len(gaps))33print(f"largest difference from lib.metrics: {max(gaps):.3f}")3435ranking, per_query = bm25[461], judgments[461] # luau string lights36print()37print("query:", queries.at[461, "query"])38print("grades in the top 10:", [per_query.get(product_id, 0) for product_id in ranking[:10]])39print("best possible grades:", sorted(per_query.values(), reverse=True)[:10])40print("exact products judged:", sum(grade == 2 for grade in per_query.values()))41print("exact in the top 10:", sum(per_query.get(product_id, 0) == 2 for product_id in ranking[:10]))42print(f"ndcg@10: {ndcg(ranking, per_query):.3f}")
python ndcg-from-scratch.pyrankings checked: 90
largest difference from lib.metrics: 0.000
query: luau string lights
grades in the top 10: [2, 2, 2, 2, 1, 1, 1, 1, 1, 1]
best possible grades: [2, 2, 2, 2, 1, 1, 1, 1, 1, 1]
exact products judged: 4
exact in the top 10: 4
ndcg@10: 1.000
Em todos os 90 rankings verificados, a versão escrita à mão nunca difere de lib.metrics em mais de 0.000.
Para luau string lights, o top 10 do BM25 contém 4 produtos exatos e recebe a pontuação 1.000. Isso não é um erro. A consulta tem apenas 4 produtos exatos avaliados; assim, o melhor top 10 possível contém esses e, em seguida, produtos parciais, e o BM25 encontrou exatamente essa ordem. Um nDCG@10 igual a 1 significa "tão bom quanto a melhor ordem dos produtos avaliados", e não "dez produtos exatos".
Regra prática: use a forma com ganho linear e log2(i + 1), com ponto de corte em 10 e o ranking ideal construído a partir de todos os produtos avaliados, e declare essa variante sempre que citar um número. Compare o nDCG somente entre execuções pontuadas com os mesmos julgamentos: novos julgamentos alteram o ranking ideal e, com ele, todas as pontuações.
Confira ndcg_score com o scikit-learn
Verifique uma métrica contra uma biblioteca que a calcula de forma independente. Na versão 1.9.1 do scikit-learn, ndcg_score usa a mesma variante que lib.metrics: as notas são os ganhos, cada um é dividido por log2(rank + 1), e o DCG de normalização é o das mesmas notas ordenadas da melhor forma, truncado em k (código-fonte do scikit-learn). A documentação cita Järvelin e Kekäläinen, embora o código implemente a forma posterior, com rank + 1 (documentação do scikit-learn). Três detalhes fazem uma chamada ingênua discordar da sua:
- Ele pontua apenas os produtos que você passa, então constrói o ranking ideal apenas a partir deles.
- Por padrão, ele faz a média dos ganhos de produtos cujas pontuações empatam (documentação do scikit-learn). Isso equivale à média sobre todas as ordens dos produtos empatados (McSherry e Najork, 2008).
- Ele recebe uma linha por consulta, com todas as linhas do mesmo tamanho, e retorna a média sobre as linhas (código-fonte do scikit-learn).
A chamada ingênua vem primeiro: ndcg_score recebe as notas dos 10 primeiros do BM25 para clear shower curtain, com pontuações que os colocam na ordem do BM25. Em seguida, monte a linha de cada consulta do jeito que lib.metrics enxerga a consulta, e compare as três execuções:
1"""Compares scikit-learn's ndcg_score with lib.metrics for one query, first with only the top 10 passed and then with every judged product in the row, and then on every test query of three runs. The prose's point rests on the ndcg@10 lines for clear shower curtain and on the 5-product lines."""2from sklearn.metrics import ndcg_score34from lib.fusion import reciprocal_rank_fusion5from lib.lexical import LexicalSearch6from lib.metrics import ndcg_at_k7from lib.semantic import SemanticSearch8from lib.store import load_products, load_queries, qrels91011def sklearn_ndcg(ranking, judgments, k=10):12 """One row for one query: every judged product, plus any retrieved product nobody judged."""13 # every judged product once, then the retrieved products nobody judged14 products = list(dict.fromkeys([*judgments, *ranking]))15 position = {product_id: i for i, product_id in enumerate(ranking)}16 grades = [[judgments.get(product_id, 0) for product_id in products]]17 # ndcg_score ranks by score, so the negated position puts rank 1 highest18 scores = [[-position.get(product_id, len(ranking)) for product_id in products]] # not retrieved: below all19 return ndcg_score(grades, scores, k=k)202122queries, judgments = load_queries("test"), qrels("test")23bm25 = LexicalSearch(load_products()).run(queries, k=100)24semantic = SemanticSearch().run(queries, k=100)25runs = {"bm25": bm25, "semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}2627top = bm25[246][:10] # clear shower curtain28# scores 10 down to 1 put the top 10 in BM25's order, so the first product scores highest29naive = ndcg_score([[judgments[246].get(product_id, 0) for product_id in top]], [list(range(10, 0, -1))], k=10)30print(f"ndcg@10, only the top 10 passed: {naive:.3f}")31print(f"ndcg@10 from lib.metrics: {ndcg_at_k(top, judgments[246], 10):.3f}")32print(f"ndcg@10, every judged product passed: {sklearn_ndcg(top, judgments[246]):.3f}")3334gaps = [abs(sklearn_ndcg(run[query_id], judgments[query_id]) - ndcg_at_k(run[query_id], judgments[query_id], 10))35 for run in runs.values() for query_id in judgments]36print("rankings compared:", len(gaps))37print(f"largest difference: {max(gaps):.3f}")3839short = bm25[246][:5] # a ranking shorter than k40print(f"5-product ranking, lib.metrics: {ndcg_at_k(short, judgments[246], 10):.3f}")41print(f"5-product ranking, scikit-learn: {sklearn_ndcg(short, judgments[246]):.3f}")
python ndcg-matches-scikit-learn.pyndcg@10, only the top 10 passed: 0.901
ndcg@10 from lib.metrics: 0.615
ndcg@10, every judged product passed: 0.615
rankings compared: 90
largest difference: 0.000
5-product ranking, lib.metrics: 0.539
5-product ranking, scikit-learn: 0.629
Passando apenas os 10 primeiros, ndcg_score retorna 0.901, contra 0.615 de lib.metrics, porque divide pela melhor ordem apenas desses dez produtos, então não consegue enxergar justamente os produtos que o BM25 deixou de fora. lib.metrics divide pela melhor ordem de todos os 253 produtos avaliados para a consulta. O sklearn_ndcg do exemplo corrige isso com uma receita. Cada linha contém todos os produtos avaliados, mais qualquer produto recuperado que ninguém avaliou, com nota 0. A receita pontua os produtos recuperados pela sua posição, e dá a todos os outros produtos uma mesma pontuação, abaixo de todas as dos produtos recuperados. Com essa receita, os dois concordam em todos os 90 rankings (maior diferença 0.000). Chame ndcg_score uma vez por consulta e calcule a média dos resultados por conta própria, porque a linha de cada consulta tem um tamanho diferente.
A receita tem uma limitação, e execuções curtas a revelam. ndcg_score trata os produtos que uma execução não recuperou como empatados nas posições vazias dentro do top k, e atribui a essas posições o ganho médio desses produtos. lib.metrics não atribui nada a uma posição vazia, porque o comprador não vê nada ali. Corte o ranking do BM25 para 5 produtos e os dois discordam: 0.539 de lib.metrics, contra 0.629 de ndcg_score. Execuções curtas acontecem: LexicalSearch retorna apenas produtos com pontuação acima de 0.
Regra prática: Informe o seu próprio nDCG, e use ndcg_score como verificação independente, com todos os produtos avaliados na linha de cada consulta e as pontuações derivadas das posições. Antes de comparar os dois, confira se cada execução tem pelo menos k produtos. Se, em vez disso, você passar as pontuações brutas de um ranqueador, desempate primeiro em uma ordem fixa, por exemplo por product_id, ou os dois vão discordar sempre que houver empates de pontuação.
Escolha uma métrica antes de comparar
Toda métrica é um modelo de um comprador. Precision@10 supõe que o comprador olha a primeira página inteira e conta os bons produtos nela. RR supõe que o comprador para no primeiro bom produto. nDCG@10 supõe que a atenção diminui ao longo da página e que um produto exato vale mais do que um parcial: com as notas do livro, o dobro. Ganhos exponenciais, 2^grau − 1 como em Burges et al. (2005), transformam as notas em ganhos de 0, 1 e 3, de modo que um produto exato vale três parciais. Como regra geral, essas métricas concordam quando dois ranqueadores estão bem distantes um do outro. Quando os ranqueadores estão próximos, a métrica pode escolher o vencedor, e por isso você a escolhe antes de olhar os resultados. Fuhr pede hipóteses declaradas antecipadamente, na forma "Queremos comparar os métodos A e B usando a métrica X" (Fuhr, 2017, seção 2.6).
Tome a recuperação semântica, o ranqueador a ser superado, e o híbrido, que o capítulo 1 não conseguiu separar dela. Escolher uma métrica faz parte de ajustar a avaliação, então faça a escolha nas 50 consultas de treino e reserve as consultas de teste para o relatório. Pontue os dois ranqueadores de quatro formas:
1"""Scores semantic retrieval and the hybrid four ways on the train queries and names the higher scorer for each metric. The prose's point rests on the "higher" lines, the count of metrics each ranker wins, and the largest gap."""2from lib.fusion import reciprocal_rank_fusion3from lib.lexical import LexicalSearch4from lib.metrics import evaluate5from lib.semantic import SemanticSearch6from lib.store import load_products, load_queries, qrels78queries, judgments = load_queries("train"), qrels("train") # choosing a metric is tuning: use train9bm25 = LexicalSearch(load_products()).run(queries, k=100)10semantic = SemanticSearch().run(queries, k=100)11runs = {"semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}1213exponential = {query_id: {product_id: 2 ** grade - 1 for product_id, grade in per_query.items()}14 for query_id, per_query in judgments.items()} # gains 0, 1, 3 instead of 0, 1, 215means = {}16for name, run in runs.items():17 scores = evaluate(run, judgments)18 means[name] = {"precision@10": scores["precision@10"].mean(), "mrr": scores["rr"].mean(),19 "ndcg@10": scores["ndcg@10"].mean(),20 "ndcg@10 with exponential gains": evaluate(run, exponential)["ndcg@10"].mean()}2122print("train queries:", len(judgments))23winners = []24for metric in means["semantic"]:25 for name in runs:26 print(f"{name} {metric}: {means[name][metric]:.3f}")27 # max keeps the first name it meets, so on an exact tie the order of runs decides28 winners.append(max(runs, key=lambda name: means[name][metric]))29 print(f"higher {metric}: {winners[-1]}")30for name in runs:31 print(f"metrics won by {name}:", winners.count(name))32print(f"largest gap: {max(abs(means['semantic'][m] - means['hybrid'][m]) for m in means['semantic']):.3f}")
python metric-choice-on-train.pytrain queries: 50
semantic precision@10: 0.502
hybrid precision@10: 0.488
higher precision@10: semantic
semantic mrr: 0.673
hybrid mrr: 0.710
higher mrr: hybrid
semantic ndcg@10: 0.772
hybrid ndcg@10: 0.774
higher ndcg@10: hybrid
semantic ndcg@10 with exponential gains: 0.709
hybrid ndcg@10 with exponential gains: 0.708
higher ndcg@10 with exponential gains: semantic
metrics won by semantic: 2
metrics won by hybrid: 2
largest gap: 0.037
As quatro métricas não concordam em um vencedor. A recuperação semântica lidera em 2 delas e o híbrido em 2, e nenhuma diferença entre os dois é maior que 0.037. Quando dois ranqueadores estão tão próximos, a métrica decide para que lado cai a diferença. A nDCG@10, a métrica principal escolhida no capítulo 1, favorece hybrid. Estas são consultas de treino, então nada disso diz qual ranqueador é o melhor.
Portanto, a escolha deve seguir o comprador, não o resultado. A loja mostra uma página de produtos e seus julgamentos são graduados, então nDCG@10 com ganhos lineares continua sendo a métrica principal, como escolhido no capítulo 1, com precision@10 e MRR ao lado.
Regra prática: Escolha uma métrica principal, seus ganhos e seu ponto de corte antes de comparar os ranqueadores, e anote-os. Recomendamos nDCG@10 com ganhos lineares quando os julgamentos são graduados e os compradores navegam por uma página. Passe para ganhos exponenciais quando uma correspondência exata vale muito mais do que uma próxima, como para uma peça de reposição que precisa encaixar, e para MRR quando a maioria das consultas tem uma única resposta certa. Reporte as outras métricas ao lado da principal, e nunca mude a métrica principal depois de ter visto qual ranqueador ela favorece.
Leia as diferenças por consulta, não só a média
A média da métrica principal sobre as consultas é um resumo para a loja, mas o comprador vê os resultados de uma única consulta. A trilha TREC Robust foi construída sobre esse ponto. Os organizadores constataram que ajustar o sistema para a média pode melhorar consultas que já vão bem, às vezes em detrimento das que vão mal (Voorhees, 2004). Por isso, antes de confiar em uma mudança na média, observe as diferenças por consulta: um número por consulta, a pontuação do novo ranqueador menos a do antigo. Elas também são a evidência usada pelos testes de significância.
Em média, a execução híbrida da loja, apresentada no capítulo 1, pontua bem acima do BM25. Compare as duas consulta por consulta em nDCG@10:
1"""Compares the hybrid and BM25 query by query on nDCG@10, then lists the three largest losses and the largest gain with its judged@10. The prose's point rests on the mean and median difference lines and on the largest-gain lines."""2from lib.fusion import reciprocal_rank_fusion3from lib.lexical import LexicalSearch4from lib.metrics import evaluate5from lib.semantic import SemanticSearch6from lib.store import load_products, load_queries, qrels78queries, judgments = load_queries("test"), qrels("test")9bm25 = LexicalSearch(load_products()).run(queries, k=100)10hybrid = reciprocal_rank_fusion([bm25, SemanticSearch().run(queries, k=100)])11before, after = evaluate(bm25, judgments), evaluate(hybrid, judgments)1213# rounded to three decimals first, so a difference that rounds to 0 counts as a tie; sorted from the largest loss up14difference = (after["ndcg@10"] - before["ndcg@10"]).round(3).sort_values() # one value per test query15print(f"mean difference: {difference.mean():.3f}")16print(f"median difference: {difference.median():.3f}")17print("hybrid better:", (difference > 0).sum())18print("bm25 better:", (difference < 0).sum())19print("tied:", (difference == 0).sum())2021print("\nhybrid's three largest losses:")22print(queries.loc[difference.index[:3], "query"].to_frame().assign(difference=difference[:3]).to_string())23# the last one after sorting: the largest gain24largest = difference.index[-1]25print("\nlargest gain:", queries.at[largest, "query"])26print(f"its gain: {difference[largest]:.3f}")27print(f"its bm25 judged@10: {before.at[largest, 'judged@10']:.3f}")28print(f"share of the mean gain from this query: {difference[largest] / difference.sum():.3f}")2930relative = after["ndcg@10"] / before["ndcg@10"] - 1 # per-query relative gains31print(f"\nrelative gain of the means: {after['ndcg@10'].mean() / before['ndcg@10'].mean() - 1:.3f}")32print(f"mean of per-query relative gains: {relative.mean():.3f}")33print(f"its bm25 ndcg@10: {before.at[largest, 'ndcg@10']:.3f}")34print(f"its relative gain: {relative[largest]:.3f}")35print(f"mean of per-query relative gains without it: {relative.drop(largest).mean():.3f}")
python per-query-hybrid-versus-bm25.pymean difference: 0.087
median difference: 0.057
hybrid better: 17
bm25 better: 7
tied: 6
hybrid's three largest losses:
query difference
query_id
293 wood floor protector mat -0.072
292 decorative white pillow -0.069
249 bistro table and chairs -0.066
largest gain: outdoor light fixtures
its gain: 0.714
its bm25 judged@10: 0.200
share of the mean gain from this query: 0.274
relative gain of the means: 0.120
mean of per-query relative gains: 0.218
its bm25 ndcg@10: 0.286
its relative gain: 2.492
mean of per-query relative gains without it: 0.140
O ganho médio é 0.087, mas a mediana é 0.057. O híbrido vence em mais consultas do que perde, 17 a 7, e empata em 6.
Uma consulta responde por grande parte do resultado. outdoor light fixtures ganha 0.714, uma fatia de 0.274 do ganho total, e o judged@10 do BM25 nela é 0.200. Para essa consulta, os 10 primeiros resultados do BM25 são em grande parte lâmpadas que ninguém avaliou, e o capítulo 1 defende que a nota 0 delas é justa, então o ganho se sustenta. Em outra consulta, os produtos não avaliados que um ranqueador deixa de fora podem ser bons. As três maiores perdas do híbrido são as consultas em que um comprador veria a busca piorar, então leia essas primeiro.
Informe a diferença como número absoluto. O ganho relativo das médias é 0.120, mas a média dos ganhos relativos por consulta é 0.218, porque uma média de razões por consulta dá mais peso às consultas em que o BM25 pontua pouco.
outdoor light fixtures, em que o BM25 pontua 0.286, contribui sozinha com um ganho relativo de 2.492. Sem essa única consulta, a média dos ganhos relativos cai para 0.140. Fuhr mostra que a variação relativa de uma média não diz nada confiável sobre a variação por consulta, e que "para a média aritmética, somente melhorias absolutas são significativas" (Fuhr, 2017, seção 2.4).
Regra prática: Para cada comparação, imprima a diferença média e a mediana, as contagens de vitórias, derrotas e empates, e as consultas com as maiores perdas, depois leia essas consultas. Verifique o judged@10 nas consultas que mais se movem antes de atribuir o mérito ao ranqueador. Informe diferenças absolutas de médias, não porcentagens.
Teste uma diferença com um teste de permutação
Uma diferença entre duas médias calculadas sobre algumas dezenas de consultas pode vir apenas do acaso: outra amostra de consultas daria uma diferença diferente. Métricas rasas agravam o problema: Buckley e Voorhees descobriram que, com uma medida como a precisão em 10, os pesquisadores precisam de muito mais de 50 consultas para distinguir sistemas de forma confiável (Buckley e Voorhees, 2000). Um teste de significância pergunta quão surpreendente seria uma diferença entre dois rankers sob a hipótese nula, a suposição de que os rankers são igualmente bons. Sua resposta é o valor-p: a probabilidade, sob a hipótese nula, de uma diferença pelo menos tão grande quanto a que você mediu. Por convenção, um valor-p abaixo de 0.05 conta como evidência de uma diferença real, e a regra do livro torna esse critério mais rigoroso quando um capítulo faz várias comparações.
Os testes deste livro são pareados: ambos os rankers são avaliados nas mesmas consultas, então cada teste trabalha com as diferenças por consulta, e as notas baixas de uma consulta difícil se cancelam. Um teste de permutação constrói diretamente as diferenças que você veria sob a hipótese nula. Se os dois rankers fossem intercambiáveis, a diferença de cada consulta teria a mesma chance de ter o sinal oposto. Então inverta cada sinal ao acaso, recalcule a média, repita milhares de vezes e conte com que frequência a média invertida fica pelo menos tão distante de 0 quanto a real. Para n consultas há 2^n padrões de sinal, 1,073,741,824 para as consultas de teste, então o teste amostra 9,999 deles, e seu valor-p é uma estimativa.
O híbrido fica atrás da recuperação semântica nas consultas de teste, e o capítulo 1 deixou em aberto se essa diferença é real. Em comparação com a recuperação semântica, as vitórias, derrotas e empates do híbrido nas consultas de teste são 9 / 14 / 7. O teste vai encontrar um déficit do híbrido maior do que o acaso explicaria? Defina uma resposta e depois execute o teste.
1"""Estimates the p-value of the hybrid's deficit against semantic retrieval by flipping each query's sign at random, once by hand and once with SciPy's permutation_test. The prose's point rests on the observed mean, the two p-value lines, and the line that compares the p-value with 0.05."""2import numpy as np3from scipy.stats import permutation_test45from lib.fusion import reciprocal_rank_fusion6from lib.lexical import LexicalSearch7from lib.metrics import evaluate8from lib.semantic import SemanticSearch9from lib.store import load_products, load_queries, qrels1011queries, judgments = load_queries("test"), qrels("test")12semantic = SemanticSearch().run(queries, k=100)13hybrid = reciprocal_rank_fusion([LexicalSearch(load_products()).run(queries, k=100), semantic])14after = evaluate(hybrid, judgments)["ndcg@10"].to_numpy()15before = evaluate(semantic, judgments)["ndcg@10"].to_numpy()16difference = after - before # hybrid minus semantic, per test query17print("test queries:", len(difference))18print(f"sign patterns for the test queries: {2 ** len(difference):,}")19print(f"observed mean difference: {difference.mean():.3f}")2021# if the two rankers were interchangeable, each query's difference would be as likely to have the other sign22# a fixed seed, so every run draws the same sign patterns23rng = np.random.default_rng(2026)24# 9,999 random sign patterns, one sign for each query in each25signs = rng.choice([-1, 1], size=(9999, len(difference)))26flipped = (signs * difference).mean(axis=1) # 9,999 mean differences under that assumption27# the 95th percentile of the flipped means' sizes28print(f"95% of flipped means are smaller than: {np.quantile(np.abs(flipped), 0.95):.3f}")29print(f"p-value by hand: {np.mean(np.abs(flipped) >= abs(difference.mean())):.3f}")3031result = permutation_test((after, before), lambda after_scores, before_scores, axis: np.mean(after_scores - before_scores, axis=axis),32 # samples: flip each query's pair of scores, which is the paired setting33 permutation_type="samples", rng=np.random.default_rng(2026))34print(f"p-value from scipy: {result.pvalue:.3f}")35print("difference at the 0.05 level:", "larger than chance" if result.pvalue < 0.05 else "within chance")
python permutation-test-by-hand.pytest queries: 30
sign patterns for the test queries: 1,073,741,824
observed mean difference: -0.018
95% of flipped means are smaller than: 0.022
p-value by hand: 0.117
p-value from scipy: 0.125
difference at the 0.05 level: within chance
O déficit do híbrido em relação à recuperação semântica é within chance no nível de 0.05. A diferença média observada é -0.018, e 95% das médias invertidas são menores que 0.022 em valor absoluto. O valor-p, a fração de médias invertidas pelo menos tão grandes quanto a observada, é 0.117.
A função permutation_test do SciPy, executada com permutation_type="samples", a configuração que a documentação dele indica para testes pareados, retorna 0.125 (documentação do SciPy). As duas estimativas diferem um pouco porque cada uma sorteia seus próprios padrões de sinal aleatórios. Um déficit real exigiria que a média superasse a dispersão, e algumas consultas que se movessem no sentido oposto poderiam fechar a diferença.
As funções de reamostragem do SciPy recebem seu gerador aleatório por meio de rng, que substitui o argumento random_state. Na versão 1.18.1 as duas formas funcionam, mas a documentação diz que "somente o argumento nomeado rng deve ser usado em código novo", porque chamadas que usam random_state vão emitir avisos após um período de transição (documentação do SciPy). Todos os exemplos deste livro passam rng com uma semente fixa.
Regra prática: Teste toda diferença sobre a qual você pretenda agir com um teste de permutação pareado sobre as diferenças por consulta. O livro decide com base nesse teste, como sua regra estabelece. Leia um valor-p acima do limite como "nenhuma evidência de diferença", nunca como "nenhuma diferença": com tão poucas consultas, um teste pode deixar passar uma diferença real, e McKechnie et al. defendem medir essas falhas junto com os falsos positivos (McKechnie et al., 2025). Nunca explique uma diferença que o teste não consegue distinguir do acaso.
Obtenha o valor p a partir de um teste t pareado
O teste t pareado responde à mesma pergunta com uma fórmula, em vez de reamostragem. Ele divide a média das diferenças por consulta pelo seu erro padrão: o desvio padrão das diferenças dividido pela raiz quadrada do número de consultas, que estima o quanto a média se deslocaria de uma amostra de consultas para outra. Se os rankers forem igualmente bons e as diferenças forem aproximadamente normais, essa razão, t, segue uma distribuição t: em forma de sino, com caudas mais pesadas que as da normal, e com um formato definido por seus graus de liberdade, aqui um a menos que o número de consultas. O valor p é a probabilidade de um t estar pelo menos tão distante de 0 em qualquer direção (Sakai, 2014, seção 3.1.1):
t = mean(d) / (sd(d) / sqrt(n)) d: the per-query differences, n: the number of queries
As diferenças de nDCG por consulta estão limitadas entre −1 e 1 e têm valores atípicos, como o ganho em outdoor light fixtures, por isso não são normais. Na prática, porém, o teste t se sustenta. Em execuções do TREC pontuadas com precisão média (MAP, outra métrica de ranqueamento) em 50 tópicos, Smucker et al. não encontraram diferença prática relevante entre os testes de aleatorização, bootstrap e t, sendo que o teste de aleatorização é o teste de permutação (Smucker et al., 2007). Em uma simulação construída a partir de dados do TREC, com conjuntos de 25, 50 e 100 tópicos, Urbano et al. constataram que "tanto o teste t quanto o teste de permutação se comportam quase de forma idêntica" (Urbano et al., 2019). Os dois estudos desaconselham, para essa tarefa, o teste de postos com sinal de Wilcoxon e o teste do sinal. O wilcoxon do SciPy também descarta, por padrão, toda consulta cuja diferença seja exatamente 0, com zero_method='wilcox' (documentação do SciPy), e muitas consultas empatam quando duas execuções diferem um pouco.
A fórmula e a reamostragem concordam nas lacunas do capítulo 1? Tome duas delas, recuperação semântica contra BM25 e o híbrido contra a recuperação semântica. O t da fórmula, calculado à mão, deve coincidir com o ttest_rel do SciPy:
1"""Computes the paired t statistic and its p-value by hand for two gaps, and checks each p-value against SciPy's ttest_rel. The prose's point rests on the t and p lines printed for each gap."""2import math34from scipy.stats import t, ttest_rel56from lib.fusion import reciprocal_rank_fusion7from lib.lexical import LexicalSearch8from lib.metrics import evaluate9from lib.semantic import SemanticSearch10from lib.store import load_products, load_queries, qrels1112queries, judgments = load_queries("test"), qrels("test")13bm25 = LexicalSearch(load_products()).run(queries, k=100)14semantic = SemanticSearch().run(queries, k=100)15runs = {"bm25": bm25, "semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}16ndcg = {name: evaluate(run, judgments)["ndcg@10"] for name, run in runs.items()} # per test query1718for after, before in [("semantic", "bm25"), ("hybrid", "semantic")]:19 difference = ndcg[after] - ndcg[before]20 n = len(difference)21 # ddof=1 divides by n - 1, the sample standard deviation the t-test uses22 standard_error = difference.std(ddof=1) / math.sqrt(n) # how much the mean would move between samples23 statistic = difference.mean() / standard_error24 p_value = 2 * t.sf(abs(statistic), df=n - 1) # both tails of the t distribution25 print(f"{after} minus {before}: {difference.mean():.3f}")26 print(f"{after} minus {before} t by hand: {statistic:.3f}")27 print(f"{after} minus {before} p by hand: {p_value:.3f}")28 print(f"{after} minus {before} p from ttest_rel: {ttest_rel(ndcg[after], ndcg[before]).pvalue:.3f}")
python paired-t-test-by-hand.pysemantic minus bm25: 0.105
semantic minus bm25 t by hand: 3.294
semantic minus bm25 p by hand: 0.003
semantic minus bm25 p from ttest_rel: 0.003
hybrid minus semantic: -0.018
hybrid minus semantic t by hand: -1.590
hybrid minus semantic p by hand: 0.123
hybrid minus semantic p from ttest_rel: 0.123
Para a recuperação semântica contra BM25, a diferença média de 0.105 dá t = 3.294 e um valor p de 0.003, o mesmo que ttest_rel fornece. Essa é uma lacuna que o acaso dificilmente produziria.
Para o híbrido contra a recuperação semântica, t = -1.590 e o valor p é 0.123. Isso está próximo do valor de 0.125 obtido pelo teste de permutação para a mesma lacuna.
Regra prática: Informe o teste t pareado, scipy.stats.ttest_rel, ao lado do teste de permutação, como uma verificação que não exige reamostragem. Quando os dois caírem de lados diferentes do limiar, diga isso e deixe que o teste de permutação decida. Não use o teste de Wilcoxon nem o teste do sinal para comparar médias de pontuação.
Informe o tamanho da diferença
Um valor-p indica quão surpreendente é uma diferença, não quão grande ela é. Em uma amostra grande, quase qualquer modificação produz uma diferença significativa, mas minúscula (Fuhr, 2017, seção 2.8). Sakai recomenda informar um tamanho de efeito e um intervalo de confiança junto de cada valor-p (Sakai, 2014). Um intervalo de confiança é um intervalo de valores plausíveis para a diferença média verdadeira: a média sobre todas as consultas como estas, avaliadas com estes julgamentos, e não sobre o tráfego de buscas da loja. Um intervalo de 95% vem de um procedimento que deve cobrir esse valor em 95% das vezes.
O bootstrap constrói um intervalo de confiança por reamostragem. Sorteie, a partir das consultas que você tem, tantas consultas quantas você tem, com reposição, de modo que algumas apareçam duas vezes e outras nenhuma. Calcule a diferença média e repita milhares de vezes. O intervalo percentil é o intervalo central de 95% das médias reamostradas. O tamanho de efeito de uma comparação pareada é a diferença média dividida pelo desvio padrão das diferenças (Sakai, 2014, seção 3.1.2). Ele mostra o quão grande é a diferença em relação ao quanto ela varia de consulta para consulta. Não é o d de Cohen, o tamanho de efeito para amostras não pareadas, e Sakai alerta contra comparar os dois diretamente.
Um intervalo percentil construído à mão pode igualar o bootstrap do SciPy com method="percentile"? Construa um à mão para a recuperação semântica contra BM25 e para o híbrido contra a recuperação semântica, confira cada um contra o SciPy e depois execute o método padrão do SciPy:
1"""Builds a 95% percentile interval by hand from 9,999 resampled means, checks it against SciPy's percentile method, then reads SciPy's default BCa interval and the effect size for each gap. The prose's point rests on the BCa low and high lines and on the line that says whether each interval includes 0."""2import numpy as np3from scipy.stats import bootstrap45from lib.fusion import reciprocal_rank_fusion6from lib.lexical import LexicalSearch7from lib.metrics import evaluate8from lib.semantic import SemanticSearch9from lib.store import load_products, load_queries, qrels1011queries, judgments = load_queries("test"), qrels("test")12bm25 = LexicalSearch(load_products()).run(queries, k=100)13semantic = SemanticSearch().run(queries, k=100)14runs = {"bm25": bm25, "semantic": semantic, "hybrid": reciprocal_rank_fusion([bm25, semantic])}15ndcg = {name: evaluate(run, judgments)["ndcg@10"] for name, run in runs.items()} # per test query1617for after, before in [("semantic", "bm25"), ("hybrid", "semantic")]:18 difference, name = (ndcg[after] - ndcg[before]).to_numpy(), f"{after} minus {before}"19 # choice draws with replacement, so a query can appear twice in one set and not at all in another20 resampled = np.random.default_rng(2026).choice(difference, size=(9999, len(difference))) # 9,999 sets of queries21 # 2.5% in each tail leaves the middle 95%22 low, high = np.percentile(resampled.mean(axis=1), [2.5, 97.5]) # the middle 95% of their means23 print(f"{name}: {difference.mean():.3f}")24 print(f"{name} interval by hand: {low:.3f} to {high:.3f}")25 percentile = bootstrap((difference,), np.mean, method="percentile", rng=np.random.default_rng(2026))26 print(f"{name} percentile interval from scipy: "27 f"{percentile.confidence_interval.low:.3f} to {percentile.confidence_interval.high:.3f}")28 # BCa is SciPy's default method, so no method argument is given29 bca = bootstrap((difference,), np.mean, rng=np.random.default_rng(2026)).confidence_interval30 print(f"{name} bca low: {bca.low:.3f}\n{name} bca high: {bca.high:.3f}")31 print(f"{name} bca interval and 0: {'includes 0' if bca.low <= 0 <= bca.high else 'excludes 0'}")32 # ddof=1: the standard deviation of the differences, with n - 1 in the denominator33 print(f"{name} effect size: {difference.mean() / difference.std(ddof=1):.3f}")
python bootstrap-interval-by-hand.pysemantic minus bm25: 0.105
semantic minus bm25 interval by hand: 0.049 to 0.172
semantic minus bm25 percentile interval from scipy: 0.049 to 0.172
semantic minus bm25 bca low: 0.055
semantic minus bm25 bca high: 0.185
semantic minus bm25 bca interval and 0: excludes 0
semantic minus bm25 effect size: 0.601
hybrid minus semantic: -0.018
hybrid minus semantic interval by hand: -0.041 to 0.003
hybrid minus semantic percentile interval from scipy: -0.041 to 0.003
hybrid minus semantic bca low: -0.042
hybrid minus semantic bca high: 0.002
hybrid minus semantic bca interval and 0: includes 0
hybrid minus semantic effect size: -0.290
O intervalo percentil do SciPy coincide com o construído à mão: 0.049 to 0.172 e -0.041 to 0.003. Seu método padrão, BCa (bias-corrected and accelerated, ou corrigido por viés e acelerado), lê percentis diferentes das mesmas médias reamostradas. Ele os desloca pelo quanto as médias reamostradas se afastam do centro em relação à média observada, e os estica pela assimetria que estima deixando de fora uma consulta por vez (código-fonte do SciPy). O harness do livro informa o BCa, projetado para médias reamostradas assimétricas como estas.
Para a recuperação semântica contra BM25, o BCa vai de 0.055 a 0.185, portanto ele excludes 0, e o tamanho de efeito é 0.601.
Para o híbrido contra a recuperação semântica, o intervalo vai de -0.042 a 0.002. Ele includes 0, e o tamanho de efeito é -0.290. Esse intervalo admite desde uma perda de alguns centésimos até um ganho de no máximo 0.002: nenhum ganho que valha a pena.
Um intervalo de bootstrap apenas aproxima seu nível, e com algumas dezenas de consultas ele fica aquém. Para verificar, trate as diferenças por consulta das 30 consultas de teste do híbrido contra a recuperação semântica como se fossem todas as consultas existentes, de modo que a diferença verdadeira seja conhecida. Em seguida, sorteie 1000 novos conjuntos do mesmo tamanho a partir delas, construa um intervalo em cada um e conte com que frequência ele cobre a diferença verdadeira:
1"""Draws new samples from the test queries' differences and counts how often a BCa or a t interval covers the known gap, at two levels. The prose's point rests on the four coverage lines and the standard-error line."""2import numpy as np3from scipy.stats import bootstrap, ttest_1samp45from lib.fusion import reciprocal_rank_fusion6from lib.lexical import LexicalSearch7from lib.metrics import evaluate8from lib.semantic import SemanticSearch9from lib.store import load_products, load_queries, qrels1011queries, judgments = load_queries("test"), qrels("test")12semantic = SemanticSearch().run(queries, k=100)13hybrid = reciprocal_rank_fusion([LexicalSearch(load_products()).run(queries, k=100), semantic])14population = (evaluate(hybrid, judgments)["ndcg@10"] - evaluate(semantic, judgments)["ndcg@10"]).to_numpy()15true_gap = population.mean() # known, because these differences stand in for every query there is1617# a fixed seed, so the coverage counts repeat on every run18rng, trials = np.random.default_rng(2026), 100019print("trials:", trials)20# binomial standard error of a proportion near 0.95, over the trials21print(f"standard error of a coverage near 0.95: {(0.95 * 0.05 / trials) ** 0.5:.3f}")22for level in [0.95, round(1 - 0.05 / 3, 4)]: # the usual level, and the level for three comparisons23 covered = {"bca": 0, "t": 0}24 for _ in range(trials):25 sample = rng.choice(population, size=len(population)) # another set of 30 queries like these26 # 1,999 resamples per interval, fewer than SciPy's default, to keep 1,000 trials quick27 bca = bootstrap((sample,), np.mean, confidence_level=level, n_resamples=1999, rng=rng).confidence_interval28 t = ttest_1samp(sample, 0).confidence_interval(level) # the interval that matches the t-test29 covered["bca"] += bca.low <= true_gap <= bca.high30 covered["t"] += t.low <= true_gap <= t.high31 for method, count in covered.items():32 print(f"{method} coverage at {level}: {count / trials:.3f}")
python interval-coverage-check.pytrials: 1000
standard error of a coverage near 0.95: 0.007
bca coverage at 0.95: 0.927
t coverage at 0.95: 0.945
bca coverage at 0.9833: 0.955
t coverage at 0.9833: 0.975
Com nível nominal de 95%, o BCa cobre a diferença verdadeira em 0.927 das vezes, e o intervalo do teste t, em 0.945. Com 0.9833, o nível que o harness usa para suas comparações planejadas, o BCa cobre 0.955 e o intervalo t, 0.975.
Cada um desses valores tem incerteza de cerca de 0.007 para cima ou para baixo. O BCa fica aquém de seu nível nas duas situações, e o intervalo t se aproxima mais do seu próprio. Por isso, um intervalo de bootstrap que mal exclui 0 merece cautela. Em uma simulação, um teste construído sobre a mesma reamostragem, o teste de deslocamento por bootstrap, "mostra um viés sistemático em direção a valores-p pequenos" (Urbano et al., 2019).
Se uma diferença importa é um juízo que nenhum teste faz por você. Para precision@10, Fuhr observa que "uma diferença de 0.02 equivale a um documento relevante a mais a cada cinco consultas" (Fuhr, 2017, seção 2.8). Para nDCG@10, decida antes de testar qual diferença justificaria o custo de uma mudança.
Regra prática: Apresente cada comparação com sua diferença média, seu intervalo de bootstrap, seu tamanho de efeito e seu valor-p. Se o intervalo incluir 0, a comparação não mostra melhora. Se ele excluir 0, mas ficar abaixo da menor diferença que valha o custo da mudança, a diferença pode ser real e, ainda assim, não valer a pena implantar. Use o intervalo para descrever o tamanho de uma diferença, não para decidir se ela existe.
Decida com antecedência o que conta como estabelecido
Cada teste em 0.05 carrega uma chance de 5% de falso positivo quando a diferença é apenas ruído, e um capítulo que executa vários testes corre esse risco várias vezes. Comparar todos os pares de 10 sistemas dessa forma resulta em uma probabilidade de cerca de 0.90 de pelo menos um resultado "significativo" falso, se toda diferença for ruído e os testes forem independentes (Sakai, 2014, seção 3). A correção de Bonferroni é uma solução simples e conservadora: quando você testa m hipóteses, testa cada uma em 0.05 dividido por m (Fuhr, 2017, seção 2.7). Ela mantém a chance de qualquer falso positivo em 0.05 ou menos, independentemente de os testes serem independentes ou não. Ela só funciona se as m comparações forem fixadas antes de você ver os resultados. Fuhr aponta o modo usual de quebrar essa condição: um autor primeiro descobre qual método concorrente tem o melhor desempenho nos dados e, então, compara sua própria abordagem apenas com esse método (Fuhr, 2017, seção 2.6).
Por isso, o livro usa uma única regra, em todos os capítulos:
- Liste as comparações planejadas nas consultas de teste antes de relatar qualquer uma delas.
- Uma diferença é estabelecida quando seu teste de permutação pareado produz um valor p abaixo do limiar de Bonferroni do capítulo: 0.05 dividido pelo número de comparações planejadas.
- Relate o teste t pareado e um intervalo bootstrap ao lado dele, sendo o intervalo no nível correspondente, 1 menos o limiar. Quando qualquer um dos dois discordar do teste de permutação, diga isso.
- Uma comparação escolhida depois de olhar os resultados dos testes é exploratória. Identifique-a como tal e nunca a chame de estabelecida.
- Comparações nas consultas de treino servem para ajuste, não como evidência.
Deixamos que o teste de permutação decida porque ele não faz suposições sobre a forma das diferenças, exigindo apenas que, sob a hipótese nula, o sinal de cada consulta seja um lance de moeda. Urbano et al. constataram que os dois métodos se comportam de forma quase idêntica (Urbano et al., 2019), o que torna o teste t uma boa verificação. Intervalos bootstrap sobre poucas dezenas de consultas cobrem menos vezes do que seu nível indica (verificação de cobertura), e é por isso que um intervalo descreve uma diferença, mas não a decide.
O capítulo 1 constrói o pipeline da loja uma etapa por vez, e essa ordem, por si só, fixa suas comparações planejadas: cada etapa contra a anterior. Isso resulta na recuperação semântica contra BM25, no híbrido contra a recuperação semântica e no híbrido com reranqueamento contra o híbrido, 3 no total. O limiar é 0.0167, e os intervalos usam um nível de 0.9833. Comparar o híbrido com reranqueamento com a recuperação semântica é exploratório, pois a recuperação semântica se tornou o ranqueador a ser superado ao obter a maior pontuação justamente nestas mesmas consultas de teste.
Regra prática: escreva a lista de comparações planejadas antes de pontuar qualquer coisa nas consultas de teste, e mantenha-a curta, pois cada comparação eleva a exigência para as demais. Quando precisar comparar muitos ranqueadores de uma só vez, a correção de Bonferroni torna-se rigorosa demais. Sakai recomenda uma análise de variância, que testa se algum dos ranqueadores difere dos demais, seguida pelo teste Tukey HSD randomizado, que compara todos os pares mantendo a chance de qualquer falso positivo no nível estabelecido (Sakai, 2014).
Comparar execuções em um harness de avaliação
O livro aplica essa regra em um harness de avaliação, que mantém tudo fixo exceto o ranqueador: as mesmas consultas, julgamentos, métricas e testes, de modo que duas execuções diferem apenas em seus rankings. lib.metrics.evaluate retorna uma linha por consulta, que é o formato que os testes pareados exigem. compare em lib.significance, um módulo curto que reúne o código deste capítulo, executa os testes sobre a coluna de uma métrica a partir de duas execuções. Ele retorna a diferença média, o intervalo de bootstrap, os valores-p do teste de permutação e do teste t, o tamanho do efeito e as vitórias, derrotas e empates. Sua função verdict aplica a regra do livro a um resultado. Mantenha os data frames por consulta e calcule as médias somente no final.
Então execute os quatro ranqueadores do capítulo 1 por ele e, em seguida, faça as 3 comparações planejadas e a exploratória:
1"""Runs chapter 1's four rankers through the harness and applies the Bonferroni threshold to the three planned comparisons and one exploratory comparison. The prose's point rests on the judged@10 lines, the established lines, and the exploratory comparison's p-value and agreement lines."""2from lib.fusion import reciprocal_rank_fusion3from lib.lexical import LexicalSearch4from lib.metrics import evaluate5from lib.recorded import cross_encoder_scores6from lib.semantic import SemanticSearch7from lib.significance import compare, verdict8from lib.store import load_products, load_queries, qrels910queries, judgments = load_queries("test"), qrels("test")11bm25 = LexicalSearch(load_products()).run(queries, k=100)12semantic = SemanticSearch().run(queries, k=100)13hybrid = reciprocal_rank_fusion([bm25, semantic])14score = {(query_id, product_id): value for query_id, product_id, value in cross_encoder_scores().itertuples(index=False)}15# chapter 1's rerank: only the top 50 are reordered; the rest keep their hybrid order16reranked = {query_id: sorted(ranking[:50], key=lambda product_id: score[(query_id, product_id)], reverse=True)17 + ranking[50:] for query_id, ranking in hybrid.items()}1819runs = {"bm25": bm25, "semantic": semantic, "hybrid": hybrid, "reranked": reranked}20scores = {name: evaluate(run, judgments) for name, run in runs.items()} # one row per test query21for name, frame in scores.items():22 print(f"{name} ndcg@10: {frame['ndcg@10'].mean():.3f}\n{name} judged@10: {frame['judged@10'].mean():.3f}")2324planned = [("semantic", "bm25"), ("hybrid", "semantic"), ("reranked", "hybrid")] # each stage against the last25exploratory = [("reranked", "semantic")] # chosen after chapter 1 saw the test means26threshold = 0.05 / len(planned) # Bonferroni, over the planned comparisons only27print(f"\nplanned comparisons: {len(planned)}\np-value threshold: {threshold:.4f}\ninterval level: {1 - threshold:.4f}")28# each planned test has a 0.95 chance of no false positive, if its gap is noise29print(f"chance of a false positive, all gaps noise, tests independent: {1 - 0.95 ** len(planned):.3f}")30established, disagreements = 0, 031for after, before in planned + exploratory:32 result, name = compare(scores[after]["ndcg@10"], scores[before]["ndcg@10"], confidence=1 - threshold), f"{after} minus {before}"33 # verdict runs on the exploratory one too, only for its agreement checks; it is never counted as established34 checks, kind = verdict(result, threshold), "planned" if (after, before) in planned else "exploratory"35 print(f"\n{name}: {result['mean difference']:.3f}\n{name} kind: {kind}")36 print(f"{name} interval: {result['ci low']:.3f} to {result['ci high']:.3f}")37 print(f"{name} permutation p: {result['permutation p']:.3f}\n{name} t-test p: {result['t-test p']:.3f}")38 print(f"{name} effect size: {result['effect size']:.3f}\n{name} wins, losses, ties: {result['wins']} / {result['losses']} / {result['ties']}")39 # only a planned comparison can be established; the exploratory one is labelled and never called so40 print(f"{name} established: {'yes' if checks['established'] and kind == 'planned' else 'no'}")41 for method in ["t-test", "interval"]:42 print(f"{name} {method} agrees: {'yes' if checks[method + ' agrees'] else 'no'}")43 if kind == "planned":44 established += checks["established"]45 # a planned comparison where the t-test or the interval disagrees with the permutation test46 disagreements += not (checks["t-test agrees"] and checks["interval agrees"])47print(f"\nplanned comparisons established: {established}\nplanned comparisons with a disagreement: {disagreements}")
python compare-chapter-one-rankers.pybm25 ndcg@10: 0.725
bm25 judged@10: 0.927
semantic ndcg@10: 0.830
semantic judged@10: 0.990
hybrid ndcg@10: 0.812
hybrid judged@10: 0.980
reranked ndcg@10: 0.798
reranked judged@10: 0.980
planned comparisons: 3
p-value threshold: 0.0167
interval level: 0.9833
chance of a false positive, all gaps noise, tests independent: 0.143
semantic minus bm25: 0.105
semantic minus bm25 kind: planned
semantic minus bm25 interval: 0.047 to 0.205
semantic minus bm25 permutation p: 0.001
semantic minus bm25 t-test p: 0.003
semantic minus bm25 effect size: 0.601
semantic minus bm25 wins, losses, ties: 21 / 7 / 2
semantic minus bm25 established: yes
semantic minus bm25 t-test agrees: yes
semantic minus bm25 interval agrees: yes
hybrid minus semantic: -0.018
hybrid minus semantic kind: planned
hybrid minus semantic interval: -0.048 to 0.006
hybrid minus semantic permutation p: 0.125
hybrid minus semantic t-test p: 0.123
hybrid minus semantic effect size: -0.290
hybrid minus semantic wins, losses, ties: 9 / 14 / 7
hybrid minus semantic established: no
hybrid minus semantic t-test agrees: yes
hybrid minus semantic interval agrees: yes
reranked minus hybrid: -0.014
reranked minus hybrid kind: planned
reranked minus hybrid interval: -0.053 to 0.020
reranked minus hybrid permutation p: 0.382
reranked minus hybrid t-test p: 0.375
reranked minus hybrid effect size: -0.165
reranked minus hybrid wins, losses, ties: 11 / 12 / 7
reranked minus hybrid established: no
reranked minus hybrid t-test agrees: yes
reranked minus hybrid interval agrees: yes
reranked minus semantic: -0.032
reranked minus semantic kind: exploratory
reranked minus semantic interval: -0.078 to -0.003
reranked minus semantic permutation p: 0.048
reranked minus semantic t-test p: 0.048
reranked minus semantic effect size: -0.377
reranked minus semantic wins, losses, ties: 9 / 16 / 5
reranked minus semantic established: no
reranked minus semantic t-test agrees: yes
reranked minus semantic interval agrees: no
planned comparisons established: 1
planned comparisons with a disagreement: 0
Produtos não julgados pesam mais no BM25, cujo judged@10 é 0.927, contra 0.990 para a recuperação semântica, 0.980 para o híbrido e 0.980 para o híbrido reordenado.
Com 3 testes, cada um com 0.05, a chance de pelo menos um falso positivo seria 0.143 se toda diferença fosse ruído e os testes fossem independentes. A correção de Bonferroni limita essa chance a 0.05 em ambos os casos. Para o nDCG@10 nas consultas de teste, com intervalos no nível de 0.9833:
| Medida | Semântico menos BM25 | Híbrido menos semântico | Reordenado menos híbrido | Reordenado menos semântico |
|---|---|---|---|---|
| Tipo | planned | planned | planned | exploratory |
| Diferença média | 0.105 | -0.018 | -0.014 | -0.032 |
| Intervalo | 0.047 to 0.205 | -0.048 to 0.006 | -0.053 to 0.020 | -0.078 to -0.003 |
| p de permutação | 0.001 | 0.125 | 0.382 | 0.048 |
| p do teste t | 0.003 | 0.123 | 0.375 | 0.048 |
| Tamanho do efeito | 0.601 | -0.290 | -0.165 | -0.377 |
| Vitórias / derrotas / empates | 21 / 7 / 2 | 9 / 14 / 7 | 11 / 12 / 7 | 9 / 16 / 5 |
| Estabelecida | yes | no | no | no |
Das 3 comparações planejadas, 1 está estabelecida: a vantagem da recuperação semântica sobre o BM25, com valor-p de permutação de 0.001. A comparação do híbrido com a recuperação semântica e a do reordenador com o híbrido não estão estabelecidas: nessas consultas, nenhuma das duas mudanças mostra melhora, e nenhuma delas se mostra pior. O harness compara o teste t e o intervalo com o teste de permutação: 0 comparações planejadas apresentam divergência.
A comparação exploratória é onde as verificações começam a divergir. Seu valor-p de permutação é 0.048, a ser comparado com 0.05 sem correção e com 0.0167 com ela, e seu intervalo vai de -0.078 to -0.003.
O teste t concorda com o teste de permutação, mas o intervalo, que exclui 0, não. Ao perguntar se cada verificação concorda com o teste de permutação, o harness responde yes para o teste t e no para o intervalo: um intervalo que exclui 0 ao lado de um valor-p acima do limiar é o tipo de divergência contra o qual alerta a verificação de cobertura. Sejam quais forem seus números, essa comparação não pode ser estabelecida, porque foi escolhida depois de ver as médias dos testes. No máximo, ela levanta uma questão para novas consultas: este reordenador fica atrás da recuperação semântica?
A decisão do capítulo 1 se mantém, por uma regra que não depende de qual ranqueador obteve a maior pontuação: o ranqueador a superar é o pipeline mais simples que nenhuma comparação planejada tenha mostrado ser superado por outro. A recuperação semântica superou o BM25, e nenhuma das etapas posteriores superou a etapa anterior.
Regra prática: Para cada mudança, informe a média de nDCG@10 e de judged@10 de cada execução, depois uma tabela como esta, com uma coluna para cada comparação e as exploratórias rotuladas. Uma mudança só é publicada quando estiver estabelecida em relação ao ranqueador a superar.
O que dá errado em produção
Uma amostra de consultas pode induzir a erro. Os resultados nas consultas de teste dependem de quais consultas caíram ali. Fuhr argumenta que o método simples de holdout não é confiável, porque seus resultados podem depender muito da divisão, e pede validação cruzada em seu lugar (Fuhr, 2017, seção 2.5). Sakai concorda que "divisões diferentes de treino/validação/teste podem produzir resultados diferentes" (Sakai, 2020). O livro mantém uma única divisão fixa, para que cada capítulo relate as mesmas consultas de teste. Para ver o quanto uma diferença pode variar, execute a comparação exploratória do harness também nas consultas de treino. Trate isso como uma ilustração, não como evidência, já que as consultas de treino servem para ajuste, como estabelece a regra:
1"""Runs the reranked-minus-semantic comparison on the test queries and on the train queries, so the verdict can be compared across the two samples. The prose's point rests on the two gap lines and the higher-scoring-run lines."""2from lib.fusion import reciprocal_rank_fusion3from lib.lexical import LexicalSearch4from lib.metrics import evaluate5from lib.recorded import cross_encoder_scores6from lib.semantic import SemanticSearch7from lib.significance import compare8from lib.store import load_products, load_queries, qrels910lexical, embeddings = LexicalSearch(load_products()), SemanticSearch()11score = {(query_id, product_id): value for query_id, product_id, value in cross_encoder_scores().itertuples(index=False)}1213for split in ["test", "train"]: # the same comparison on another sample of the store's queries14 queries, judgments = load_queries(split), qrels(split)15 semantic = embeddings.run(queries, k=100)16 hybrid = reciprocal_rank_fusion([lexical.run(queries, k=100), semantic])17 # as in chapter 1: rerank the top 50 and keep the rest in hybrid order18 reranked = {query_id: sorted(ranking[:50], key=lambda product_id: score[(query_id, product_id)], reverse=True)19 + ranking[50:] for query_id, ranking in hybrid.items()}20 result = compare(evaluate(reranked, judgments)["ndcg@10"], evaluate(semantic, judgments)["ndcg@10"])21 gap = result["mean difference"]22 print(f"{split} queries:", len(judgments))23 print(f"{split} reranked minus semantic: {gap:.3f}")24 print(f"{split} higher-scoring run:", "reranked" if gap > 0 else "semantic" if gap < 0 else "neither")25 if split == "test":26 print(f"test permutation p: {result['permutation p']:.3f}")
python split-changes-the-verdict.pytest queries: 30
test reranked minus semantic: -0.032
test higher-scoring run: semantic
test permutation p: 0.048
train queries: 50
train reranked minus semantic: 0.014
train higher-scoring run: reranked
A execução com maior pontuação é semantic nas consultas de teste e reranked nas consultas de treino, portanto qual execução pontua mais muda conforme a divisão.
Nas 30 consultas de teste, a recuperação híbrida com reranqueamento menos a recuperação semântica é -0.032 (p de permutação = 0.048). Nas 50 consultas de treino, é 0.014. Um valor-p tão próximo de 0.05 em uma única amostra é uma base fraca. O capítulo 11 trata de manter as consultas de teste fora de todas as escolhas.
Reutilizar as consultas de teste equivale a testar muitas hipóteses. Cada mudança que você testa nas mesmas consultas acrescenta uma comparação, mesmo que ao longo de meses. Fuhr observa que "a reutilização da coleção também é um caso de teste de múltiplas hipóteses" (Fuhr, 2017, seção 2.7). Mantenha um registro das comparações executadas nas suas consultas de teste e conte-as ao definir o limiar.
Pontuações empatadas tornam as execuções não repetíveis. Dois produtos com a mesma pontuação podem aparecer em qualquer ordem, e a indexação com múltiplas threads pode tornar a ordem não determinística quando as pontuações empatam (Lin and Yang, 2019). Mesmo uma ordem repetível pode ser arbitrária: um empate fica com qualquer ordem que a seleção top-k de uma biblioteca, ou a entrada de uma ordenação estável, deixe por acaso. Por isso, os módulos do livro desempatam por product_id. LexicalSearch e lib.fusion ordenam pontuações iguais por ele, e SemanticSearch ordena de forma estável vetores armazenados na ordem de product_id. Com todas as versões fixadas, re-check examples executa novamente cada exemplo contra sua saída registrada, de modo que qualquer mudança nessas ordens apareceria. No seu próprio sistema, desempate em uma ordem fixa que não carregue informação, como por product_id, antes de calcular as pontuações.
Produtos não avaliados reduzem a pontuação de um ranqueador. Um ranqueador que exibe produtos que ninguém avaliou perde nDCG neles, mesmo quando são bons. Verifique judged@10 antes de testar, e peça que novos produtos sejam avaliados quando esse valor cair.
Regra prática: registre cada comparação que você executar nas consultas de teste, trate um resultado limítrofe ou exploratório como uma questão para novas consultas, desempate pontuações em uma ordem fixa e informe judged@10 ao lado de cada nDCG@10.
Decisões tomadas neste capítulo
Cada escolha abaixo é o padrão do livro a partir daqui. Um capítulo posterior muda uma delas somente com um motivo que ele declara.
- Métrica principal: nDCG@10 com ganhos lineares (as notas 2, 1 e 0), um desconto log2(i + 1) e um ranking ideal a partir de todos os produtos avaliados. Reporte precision@10 e MRR ao lado dela. Relevante significa exato.
- Nossas próprias métricas são a referência. O livro reporta
lib.metricse confere o resultado comndcg_scoredo scikit-learn, com todos os produtos avaliados em cada linha. - Toda comparação mostra as diferenças por consulta: média e mediana, vitórias, derrotas e empates, as maiores derrotas e o judged@10 nas consultas que mais se movem.
- A regra para uma diferença estabelecida: liste primeiro as comparações planejadas nas consultas de teste. Uma diferença é estabelecida quando seu teste de permutação, com 9,999 inversões aleatórias de sinal, dá um p-valor abaixo de 0.05 dividido pelo número de comparações planejadas. Reporte ao lado dele o teste t pareado e um intervalo de confiança bootstrap BCa no nível correspondente, e diga quando os dois divergirem. Rotule como exploratórias as comparações escolhidas depois de ver os resultados de teste, e nunca as chame de estabelecidas. Use consultas de treino somente para ajuste.
- Uma diferença não estabelecida é reportada como "nenhuma melhora demonstrada", nunca como uma derrota, e nunca é explicada.
- Toda reamostragem usa
rngcom uma semente fixa, por meio delib.significance. - O que as comparações planejadas ensinaram: das do capítulo 1, a vantagem da recuperação semântica sobre o BM25 é estabelecida, e as outras duas não são. Por isso a recuperação semântica continua sendo o ranqueador a ser superado. Toda mudança posterior é testada no harness contra o ranqueador que ela altera, e só é adotada se superar o ranqueador a ser superado.
Este capítulo, nesta edição
Edição 2026.11.10Exemplos aprovados em 19 de nov de 202612 de 12 exemplos exemplos deste capítulo passam
Traduzido do livro em inglês, edição 2026.11.10.